KILLED
proof of input_UAHJhibu11.trs
# AProVE Commit ID: aff8ecad908e01718a4c36e68d2e55d5e0f16e15 fuhs 20220216 unpublished


The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF).

(0) CpxTRS
(1) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
(2) CpxTRS
(3) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms]
(4) CpxTRS
(5) CpxTrsToCdtProof [UPPER BOUND(ID), 48 ms]
(6) CdtProblem
    (7) CdtToCpxRelTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (8) CpxRelTRS
    (9) RelTrsToDecreasingLoopProblemProof [LOWER BOUND(ID), 0 ms]
    (10) TRS for Loop Detection
    (11) RenamingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (12) CpxRelTRS
        (13) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
        (14) typed CpxTrs
        (15) OrderProof [LOWER BOUND(ID), 0 ms]
        (16) typed CpxTrs
        (17) RewriteLemmaProof [LOWER BOUND(ID), 6942 ms]
        (18) typed CpxTrs
(19) RelTrsToWeightedTrsProof [UPPER BOUND(ID), 0 ms]
(20) CpxWeightedTrs
    (21) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (22) CpxTypedWeightedTrs
    (23) CompletionProof [UPPER BOUND(ID), 0 ms]
    (24) CpxTypedWeightedCompleteTrs
        (25) NarrowingProof [BOTH BOUNDS(ID, ID), 1486 ms]
        (26) CpxTypedWeightedCompleteTrs
        (27) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 5 ms]
        (28) CpxRNTS
        (29) SimplificationProof [BOTH BOUNDS(ID, ID), 10 ms]
        (30) CpxRNTS
    (31) CompletionProof [UPPER BOUND(ID), 0 ms]
    (32) CpxTypedWeightedCompleteTrs
        (33) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (34) CpxRNTS
(35) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms]
(36) CdtProblem
    (37) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (38) CdtProblem
    (39) CdtToCpxRelTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
    (40) CpxRelTRS
        (41) RelTrsToTrsProof [UPPER BOUND(ID), 0 ms]
        (42) CpxTRS
        (43) RelTrsToWeightedTrsProof [BOTH BOUNDS(ID, ID), 0 ms]
        (44) CpxWeightedTrs
            (45) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
            (46) CpxTypedWeightedTrs
            (47) CompletionProof [UPPER BOUND(ID), 0 ms]
            (48) CpxTypedWeightedCompleteTrs
            (49) CompletionProof [UPPER BOUND(ID), 0 ms]
            (50) CpxTypedWeightedCompleteTrs
                (51) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
                (52) CpxRNTS
    (53) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 30 ms]
    (54) CdtProblem
        (55) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
        (56) CdtProblem
        (57) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 102 ms]
        (58) CdtProblem
        (59) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 14 ms]
        (60) CdtProblem
        (61) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 38 ms]
        (62) CdtProblem
        (63) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 2 ms]
        (64) CdtProblem
        (65) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 24 ms]
        (66) CdtProblem
        (67) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
        (68) CdtProblem
        (69) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (70) CdtProblem
        (71) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
        (72) CdtProblem
        (73) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 61 ms]
        (74) CdtProblem
        (75) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
        (76) CdtProblem
        (77) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 98 ms]
        (78) CdtProblem
        (79) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 17 ms]
        (80) CdtProblem
        (81) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 103 ms]
        (82) CdtProblem
        (83) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
        (84) CdtProblem
        (85) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 31 ms]
        (86) CdtProblem
        (87) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 10 ms]
        (88) CdtProblem
        (89) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
        (90) CdtProblem
        (91) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 58 ms]
        (92) CdtProblem
        (93) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 18 ms]
        (94) CdtProblem
        (95) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 20 ms]
        (96) CdtProblem
        (97) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 124 ms]
        (98) CdtProblem
        (99) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 8 ms]
        (100) CdtProblem
        (101) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 9 ms]
        (102) CdtProblem
        (103) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 146 ms]
        (104) CdtProblem
        (105) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 20 ms]
        (106) CdtProblem
        (107) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 121 ms]
        (108) CdtProblem
        (109) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 15 ms]
        (110) CdtProblem
        (111) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 31 ms]
        (112) CdtProblem
        (113) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 77 ms]
        (114) CdtProblem
        (115) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 9 ms]
        (116) CdtProblem
        (117) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 1 ms]
        (118) CdtProblem
        (119) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 80 ms]
        (120) CdtProblem
        (121) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 9 ms]
        (122) CdtProblem
        (123) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 24 ms]
        (124) CdtProblem
        (125) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 325 ms]
        (126) CdtProblem
        (127) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 42 ms]
        (128) CdtProblem
        (129) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 407 ms]
        (130) CdtProblem
        (131) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 60 ms]
        (132) CdtProblem
        (133) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 419 ms]
        (134) CdtProblem
        (135) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 35 ms]
        (136) CdtProblem
        (137) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 692 ms]
        (138) CdtProblem
        (139) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 41 ms]
        (140) CdtProblem
        (141) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 706 ms]
        (142) CdtProblem
        (143) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 98 ms]
        (144) CdtProblem
        (145) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 587 ms]
        (146) CdtProblem
        (147) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 84 ms]
        (148) CdtProblem
        (149) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 770 ms]
        (150) CdtProblem
        (151) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 106 ms]
        (152) CdtProblem
        (153) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 1036 ms]
        (154) CdtProblem
        (155) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 106 ms]
        (156) CdtProblem
        (157) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 1245 ms]
        (158) CdtProblem
        (159) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 146 ms]
        (160) CdtProblem
        (161) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 1255 ms]
        (162) CdtProblem
        (163) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 184 ms]
        (164) CdtProblem
        (165) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 948 ms]
        (166) CdtProblem
        (167) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 199 ms]
        (168) CdtProblem


----------------------------------------

(0)
Obligation:
The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   a__natsFrom(N) -> cons(mark(N), natsFrom(s(N)))
   a__fst(pair(XS, YS)) -> mark(XS)
   a__snd(pair(XS, YS)) -> mark(YS)
   a__splitAt(0, XS) -> pair(nil, mark(XS))
   a__splitAt(s(N), cons(X, XS)) -> a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
   a__u(pair(YS, ZS), N, X, XS) -> pair(cons(mark(X), YS), mark(ZS))
   a__head(cons(N, XS)) -> mark(N)
   a__tail(cons(N, XS)) -> mark(XS)
   a__sel(N, XS) -> a__head(a__afterNth(mark(N), mark(XS)))
   a__take(N, XS) -> a__fst(a__splitAt(mark(N), mark(XS)))
   a__afterNth(N, XS) -> a__snd(a__splitAt(mark(N), mark(XS)))
   mark(natsFrom(X)) -> a__natsFrom(mark(X))
   mark(fst(X)) -> a__fst(mark(X))
   mark(snd(X)) -> a__snd(mark(X))
   mark(splitAt(X1, X2)) -> a__splitAt(mark(X1), mark(X2))
   mark(u(X1, X2, X3, X4)) -> a__u(mark(X1), X2, X3, X4)
   mark(head(X)) -> a__head(mark(X))
   mark(tail(X)) -> a__tail(mark(X))
   mark(sel(X1, X2)) -> a__sel(mark(X1), mark(X2))
   mark(afterNth(X1, X2)) -> a__afterNth(mark(X1), mark(X2))
   mark(take(X1, X2)) -> a__take(mark(X1), mark(X2))
   mark(cons(X1, X2)) -> cons(mark(X1), X2)
   mark(s(X)) -> s(mark(X))
   mark(pair(X1, X2)) -> pair(mark(X1), mark(X2))
   mark(0) -> 0
   mark(nil) -> nil
   a__natsFrom(X) -> natsFrom(X)
   a__fst(X) -> fst(X)
   a__snd(X) -> snd(X)
   a__splitAt(X1, X2) -> splitAt(X1, X2)
   a__u(X1, X2, X3, X4) -> u(X1, X2, X3, X4)
   a__head(X) -> head(X)
   a__tail(X) -> tail(X)
   a__sel(X1, X2) -> sel(X1, X2)
   a__afterNth(X1, X2) -> afterNth(X1, X2)
   a__take(X1, X2) -> take(X1, X2)

S is empty.
Rewrite Strategy: PARALLEL_INNERMOST
----------------------------------------

(1) RenamingProof (BOTH BOUNDS(ID, ID))
Renamed function symbols to avoid clashes with predefined symbol.
----------------------------------------

(2)
Obligation:
The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   a__natsFrom(N) -> cons(mark(N), natsFrom(s(N)))
   a__fst(pair(XS, YS)) -> mark(XS)
   a__snd(pair(XS, YS)) -> mark(YS)
   a__splitAt(0', XS) -> pair(nil, mark(XS))
   a__splitAt(s(N), cons(X, XS)) -> a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
   a__u(pair(YS, ZS), N, X, XS) -> pair(cons(mark(X), YS), mark(ZS))
   a__head(cons(N, XS)) -> mark(N)
   a__tail(cons(N, XS)) -> mark(XS)
   a__sel(N, XS) -> a__head(a__afterNth(mark(N), mark(XS)))
   a__take(N, XS) -> a__fst(a__splitAt(mark(N), mark(XS)))
   a__afterNth(N, XS) -> a__snd(a__splitAt(mark(N), mark(XS)))
   mark(natsFrom(X)) -> a__natsFrom(mark(X))
   mark(fst(X)) -> a__fst(mark(X))
   mark(snd(X)) -> a__snd(mark(X))
   mark(splitAt(X1, X2)) -> a__splitAt(mark(X1), mark(X2))
   mark(u(X1, X2, X3, X4)) -> a__u(mark(X1), X2, X3, X4)
   mark(head(X)) -> a__head(mark(X))
   mark(tail(X)) -> a__tail(mark(X))
   mark(sel(X1, X2)) -> a__sel(mark(X1), mark(X2))
   mark(afterNth(X1, X2)) -> a__afterNth(mark(X1), mark(X2))
   mark(take(X1, X2)) -> a__take(mark(X1), mark(X2))
   mark(cons(X1, X2)) -> cons(mark(X1), X2)
   mark(s(X)) -> s(mark(X))
   mark(pair(X1, X2)) -> pair(mark(X1), mark(X2))
   mark(0') -> 0'
   mark(nil) -> nil
   a__natsFrom(X) -> natsFrom(X)
   a__fst(X) -> fst(X)
   a__snd(X) -> snd(X)
   a__splitAt(X1, X2) -> splitAt(X1, X2)
   a__u(X1, X2, X3, X4) -> u(X1, X2, X3, X4)
   a__head(X) -> head(X)
   a__tail(X) -> tail(X)
   a__sel(X1, X2) -> sel(X1, X2)
   a__afterNth(X1, X2) -> afterNth(X1, X2)
   a__take(X1, X2) -> take(X1, X2)

S is empty.
Rewrite Strategy: PARALLEL_INNERMOST
----------------------------------------

(3) RelTrsToTrsProof (UPPER BOUND(ID))
transformed relative TRS to TRS
----------------------------------------

(4)
Obligation:
The Runtime Complexity (parallel-innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   a__natsFrom(N) -> cons(mark(N), natsFrom(s(N)))
   a__fst(pair(XS, YS)) -> mark(XS)
   a__snd(pair(XS, YS)) -> mark(YS)
   a__splitAt(0, XS) -> pair(nil, mark(XS))
   a__splitAt(s(N), cons(X, XS)) -> a__u(a__splitAt(mark(N), mark(XS)), N, X, XS)
   a__u(pair(YS, ZS), N, X, XS) -> pair(cons(mark(X), YS), mark(ZS))
   a__head(cons(N, XS)) -> mark(N)
   a__tail(cons(N, XS)) -> mark(XS)
   a__sel(N, XS) -> a__head(a__afterNth(mark(N), mark(XS)))
   a__take(N, XS) -> a__fst(a__splitAt(mark(N), mark(XS)))
   a__afterNth(N, XS) -> a__snd(a__splitAt(mark(N), mark(XS)))
   mark(natsFrom(X)) -> a__natsFrom(mark(X))
   mark(fst(X)) -> a__fst(mark(X))
   mark(snd(X)) -> a__snd(mark(X))
   mark(splitAt(X1, X2)) -> a__splitAt(mark(X1), mark(X2))
   mark(u(X1, X2, X3, X4)) -> a__u(mark(X1), X2, X3, X4)
   mark(head(X)) -> a__head(mark(X))
   mark(tail(X)) -> a__tail(mark(X))
   mark(sel(X1, X2)) -> a__sel(mark(X1), mark(X2))
   mark(afterNth(X1, X2)) -> a__afterNth(mark(X1), mark(X2))
   mark(take(X1, X2)) -> a__take(mark(X1), mark(X2))
   mark(cons(X1, X2)) -> cons(mark(X1), X2)
   mark(s(X)) -> s(mark(X))
   mark(pair(X1, X2)) -> pair(mark(X1), mark(X2))
   mark(0) -> 0
   mark(nil) -> nil
   a__natsFrom(X) -> natsFrom(X)
   a__fst(X) -> fst(X)
   a__snd(X) -> snd(X)
   a__splitAt(X1, X2) -> splitAt(X1, X2)
   a__u(X1, X2, X3, X4) -> u(X1, X2, X3, X4)
   a__head(X) -> head(X)
   a__tail(X) -> tail(X)
   a__sel(X1, X2) -> sel(X1, X2)
   a__afterNth(X1, X2) -> afterNth(X1, X2)
   a__take(X1, X2) -> take(X1, X2)

S is empty.
Rewrite Strategy: PARALLEL_INNERMOST
----------------------------------------

(5) CpxTrsToCdtProof (UPPER BOUND(ID))
Converted Cpx (relative) TRS with rewrite strategy PARALLEL_INNERMOST to CDT
----------------------------------------

(6)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__NATSFROM(z0) -> c1
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__FST(z0) -> c3
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SND(z0) -> c5
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c7(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c8(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z2))
   A__SPLITAT(z0, z1) -> c9
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__U(z0, z1, z2, z3) -> c12
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__HEAD(z0) -> c14
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__TAIL(z0) -> c16
   A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   A__SEL(z0, z1) -> c19
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__TAKE(z0, z1) -> c22
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c25
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   MARK(0) -> c44
   MARK(nil) -> c45
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__NATSFROM(z0) -> c1
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__FST(z0) -> c3
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SND(z0) -> c5
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c7(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c8(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z2))
   A__SPLITAT(z0, z1) -> c9
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__U(z0, z1, z2, z3) -> c12
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__HEAD(z0) -> c14
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__TAIL(z0) -> c16
   A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   A__SEL(z0, z1) -> c19
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__TAKE(z0, z1) -> c22
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c25
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   MARK(0) -> c44
   MARK(nil) -> c45
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2, MARK_1

Compound Symbols:   c_1, c1, c2_1, c3, c4_1, c5, c6_1, c7_3, c8_3, c9, c10_1, c11_1, c12, c13_1, c14, c15_1, c16, c17_3, c18_3, c19, c20_3, c21_3, c22, c23_3, c24_3, c25, c26_2, c27_2, c28_2, c29_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c44, c45


----------------------------------------

(7) CdtToCpxRelTrsProof (BOTH BOUNDS(ID, ID))
Converted S to standard rules, and D \ S as well as R to relative rules.
----------------------------------------

(8)
Obligation:
The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   A__NATSFROM(z0) -> c(MARK(z0))
   A__NATSFROM(z0) -> c1
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__FST(z0) -> c3
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SND(z0) -> c5
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c7(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c8(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z2))
   A__SPLITAT(z0, z1) -> c9
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__U(z0, z1, z2, z3) -> c12
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__HEAD(z0) -> c14
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__TAIL(z0) -> c16
   A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   A__SEL(z0, z1) -> c19
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__TAKE(z0, z1) -> c22
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c25
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   MARK(0) -> c44
   MARK(nil) -> c45

The (relative) TRS S consists of the following rules:

   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil

Rewrite Strategy: INNERMOST
----------------------------------------

(9) RelTrsToDecreasingLoopProblemProof (LOWER BOUND(ID))
Transformed a relative TRS into a decreasing-loop problem.
----------------------------------------

(10)
Obligation:
Analyzing the following TRS for decreasing loops:

The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   A__NATSFROM(z0) -> c(MARK(z0))
   A__NATSFROM(z0) -> c1
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__FST(z0) -> c3
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SND(z0) -> c5
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c7(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c8(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z2))
   A__SPLITAT(z0, z1) -> c9
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__U(z0, z1, z2, z3) -> c12
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__HEAD(z0) -> c14
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__TAIL(z0) -> c16
   A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   A__SEL(z0, z1) -> c19
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__TAKE(z0, z1) -> c22
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c25
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   MARK(0) -> c44
   MARK(nil) -> c45

The (relative) TRS S consists of the following rules:

   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil

Rewrite Strategy: INNERMOST
----------------------------------------

(11) RenamingProof (BOTH BOUNDS(ID, ID))
Renamed function symbols to avoid clashes with predefined symbol.
----------------------------------------

(12)
Obligation:
The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   A__NATSFROM(z0) -> c(MARK(z0))
   A__NATSFROM(z0) -> c1
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__FST(z0) -> c3
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SND(z0) -> c5
   A__SPLITAT(0', z0) -> c6(MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c7(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c8(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z2))
   A__SPLITAT(z0, z1) -> c9
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__U(z0, z1, z2, z3) -> c12
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__HEAD(z0) -> c14
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__TAIL(z0) -> c16
   A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   A__SEL(z0, z1) -> c19
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__TAKE(z0, z1) -> c22
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c25
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   MARK(0') -> c44
   MARK(nil) -> c45

The (relative) TRS S consists of the following rules:

   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0', z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0') -> 0'
   mark(nil) -> nil

Rewrite Strategy: INNERMOST
----------------------------------------

(13) TypeInferenceProof (BOTH BOUNDS(ID, ID))
Inferred types.
----------------------------------------

(14)
Obligation:
Innermost TRS:
Rules:
A__NATSFROM(z0) -> c(MARK(z0))
A__NATSFROM(z0) -> c1
A__FST(pair(z0, z1)) -> c2(MARK(z0))
A__FST(z0) -> c3
A__SND(pair(z0, z1)) -> c4(MARK(z1))
A__SND(z0) -> c5
A__SPLITAT(0', z0) -> c6(MARK(z0))
A__SPLITAT(s(z0), cons(z1, z2)) -> c7(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z0))
A__SPLITAT(s(z0), cons(z1, z2)) -> c8(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z2))
A__SPLITAT(z0, z1) -> c9
A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
A__U(z0, z1, z2, z3) -> c12
A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
A__HEAD(z0) -> c14
A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
A__TAIL(z0) -> c16
A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
A__SEL(z0, z1) -> c19
A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
A__TAKE(z0, z1) -> c22
A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
A__AFTERNTH(z0, z1) -> c25
MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
MARK(cons(z0, z1)) -> c40(MARK(z0))
MARK(s(z0)) -> c41(MARK(z0))
MARK(pair(z0, z1)) -> c42(MARK(z0))
MARK(pair(z0, z1)) -> c43(MARK(z1))
MARK(0') -> c44
MARK(nil) -> c45
a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
a__natsFrom(z0) -> natsFrom(z0)
a__fst(pair(z0, z1)) -> mark(z0)
a__fst(z0) -> fst(z0)
a__snd(pair(z0, z1)) -> mark(z1)
a__snd(z0) -> snd(z0)
a__splitAt(0', z0) -> pair(nil, mark(z0))
a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
a__splitAt(z0, z1) -> splitAt(z0, z1)
a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
a__head(cons(z0, z1)) -> mark(z0)
a__head(z0) -> head(z0)
a__tail(cons(z0, z1)) -> mark(z1)
a__tail(z0) -> tail(z0)
a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
a__sel(z0, z1) -> sel(z0, z1)
a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
a__take(z0, z1) -> take(z0, z1)
a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
a__afterNth(z0, z1) -> afterNth(z0, z1)
mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
mark(fst(z0)) -> a__fst(mark(z0))
mark(snd(z0)) -> a__snd(mark(z0))
mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
mark(head(z0)) -> a__head(mark(z0))
mark(tail(z0)) -> a__tail(mark(z0))
mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
mark(cons(z0, z1)) -> cons(mark(z0), z1)
mark(s(z0)) -> s(mark(z0))
mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
mark(0') -> 0'
mark(nil) -> nil

Types:
A__NATSFROM :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c:c1
c :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c:c1
MARK :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c1 :: c:c1
A__FST :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c2:c3
pair :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c2 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c2:c3
c3 :: c2:c3
A__SND :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c4:c5
c4 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c4:c5
c5 :: c4:c5
A__SPLITAT :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c6:c7:c8:c9
0' :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c6 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c6:c7:c8:c9
s :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
cons :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c7 :: c10:c11:c12 -> c6:c7:c8:c9 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c6:c7:c8:c9
A__U :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c10:c11:c12
a__splitAt :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
mark :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c8 :: c10:c11:c12 -> c6:c7:c8:c9 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c6:c7:c8:c9
c9 :: c6:c7:c8:c9
c10 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c10:c11:c12
c11 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c10:c11:c12
c12 :: c10:c11:c12
A__HEAD :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c13:c14
c13 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c13:c14
c14 :: c13:c14
A__TAIL :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c15:c16
c15 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c15:c16
c16 :: c15:c16
A__SEL :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c17:c18:c19
c17 :: c13:c14 -> c23:c24:c25 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c17:c18:c19
a__afterNth :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
A__AFTERNTH :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c23:c24:c25
c18 :: c13:c14 -> c23:c24:c25 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c17:c18:c19
c19 :: c17:c18:c19
A__TAKE :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c20:c21:c22
c20 :: c2:c3 -> c6:c7:c8:c9 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c20:c21:c22
c21 :: c2:c3 -> c6:c7:c8:c9 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c20:c21:c22
c22 :: c20:c21:c22
c23 :: c4:c5 -> c6:c7:c8:c9 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c23:c24:c25
c24 :: c4:c5 -> c6:c7:c8:c9 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c23:c24:c25
c25 :: c23:c24:c25
natsFrom :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c26 :: c:c1 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
fst :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c27 :: c2:c3 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
snd :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c28 :: c4:c5 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
splitAt :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c29 :: c6:c7:c8:c9 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c30 :: c6:c7:c8:c9 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
u :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c31 :: c10:c11:c12 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
head :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c32 :: c13:c14 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
tail :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c33 :: c15:c16 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
sel :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c34 :: c17:c18:c19 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c35 :: c17:c18:c19 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
afterNth :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c36 :: c23:c24:c25 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c37 :: c23:c24:c25 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
take :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c38 :: c20:c21:c22 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c39 :: c20:c21:c22 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c40 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c41 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c42 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c43 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c44 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
nil :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c45 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
a__natsFrom :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__fst :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__snd :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__u :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__head :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__tail :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__sel :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__take :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
hole_c:c11_46 :: c:c1
hole_pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil2_46 :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
hole_c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c453_46 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
hole_c2:c34_46 :: c2:c3
hole_c4:c55_46 :: c4:c5
hole_c6:c7:c8:c96_46 :: c6:c7:c8:c9
hole_c10:c11:c127_46 :: c10:c11:c12
hole_c13:c148_46 :: c13:c14
hole_c15:c169_46 :: c15:c16
hole_c17:c18:c1910_46 :: c17:c18:c19
hole_c23:c24:c2511_46 :: c23:c24:c25
hole_c20:c21:c2212_46 :: c20:c21:c22
gen_pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil13_46 :: Nat -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
gen_c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c4514_46 :: Nat -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
gen_c6:c7:c8:c915_46 :: Nat -> c6:c7:c8:c9

----------------------------------------

(15) OrderProof (LOWER BOUND(ID))
Heuristically decided to analyse the following defined symbols:
A__NATSFROM, MARK, A__FST, A__SND, A__SPLITAT, A__U, a__splitAt, mark, A__HEAD, A__TAIL, a__afterNth, a__natsFrom, a__fst, a__snd, a__u, a__head, a__tail

They will be analysed ascendingly in the following order:
A__NATSFROM = MARK
A__NATSFROM = A__FST
A__NATSFROM = A__SND
A__NATSFROM = A__SPLITAT
A__NATSFROM = A__U
A__NATSFROM = A__HEAD
A__NATSFROM = A__TAIL
MARK = A__FST
MARK = A__SND
MARK = A__SPLITAT
MARK = A__U
a__splitAt < MARK
mark < MARK
MARK = A__HEAD
MARK = A__TAIL
a__afterNth < MARK
A__FST = A__SND
A__FST = A__SPLITAT
A__FST = A__U
A__FST = A__HEAD
A__FST = A__TAIL
A__SND = A__SPLITAT
A__SND = A__U
A__SND = A__HEAD
A__SND = A__TAIL
A__SPLITAT = A__U
a__splitAt < A__SPLITAT
mark < A__SPLITAT
A__SPLITAT = A__HEAD
A__SPLITAT = A__TAIL
A__U = A__HEAD
A__U = A__TAIL
a__splitAt = mark
a__splitAt = a__afterNth
a__splitAt = a__natsFrom
a__splitAt = a__fst
a__splitAt = a__snd
a__splitAt = a__u
a__splitAt = a__head
a__splitAt = a__tail
mark = a__afterNth
mark = a__natsFrom
mark = a__fst
mark = a__snd
mark = a__u
mark = a__head
mark = a__tail
A__HEAD = A__TAIL
a__afterNth = a__natsFrom
a__afterNth = a__fst
a__afterNth = a__snd
a__afterNth = a__u
a__afterNth = a__head
a__afterNth = a__tail
a__natsFrom = a__fst
a__natsFrom = a__snd
a__natsFrom = a__u
a__natsFrom = a__head
a__natsFrom = a__tail
a__fst = a__snd
a__fst = a__u
a__fst = a__head
a__fst = a__tail
a__snd = a__u
a__snd = a__head
a__snd = a__tail
a__u = a__head
a__u = a__tail
a__head = a__tail

----------------------------------------

(16)
Obligation:
Innermost TRS:
Rules:
A__NATSFROM(z0) -> c(MARK(z0))
A__NATSFROM(z0) -> c1
A__FST(pair(z0, z1)) -> c2(MARK(z0))
A__FST(z0) -> c3
A__SND(pair(z0, z1)) -> c4(MARK(z1))
A__SND(z0) -> c5
A__SPLITAT(0', z0) -> c6(MARK(z0))
A__SPLITAT(s(z0), cons(z1, z2)) -> c7(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z0))
A__SPLITAT(s(z0), cons(z1, z2)) -> c8(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z2))
A__SPLITAT(z0, z1) -> c9
A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
A__U(z0, z1, z2, z3) -> c12
A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
A__HEAD(z0) -> c14
A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
A__TAIL(z0) -> c16
A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
A__SEL(z0, z1) -> c19
A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
A__TAKE(z0, z1) -> c22
A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
A__AFTERNTH(z0, z1) -> c25
MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
MARK(cons(z0, z1)) -> c40(MARK(z0))
MARK(s(z0)) -> c41(MARK(z0))
MARK(pair(z0, z1)) -> c42(MARK(z0))
MARK(pair(z0, z1)) -> c43(MARK(z1))
MARK(0') -> c44
MARK(nil) -> c45
a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
a__natsFrom(z0) -> natsFrom(z0)
a__fst(pair(z0, z1)) -> mark(z0)
a__fst(z0) -> fst(z0)
a__snd(pair(z0, z1)) -> mark(z1)
a__snd(z0) -> snd(z0)
a__splitAt(0', z0) -> pair(nil, mark(z0))
a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
a__splitAt(z0, z1) -> splitAt(z0, z1)
a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
a__head(cons(z0, z1)) -> mark(z0)
a__head(z0) -> head(z0)
a__tail(cons(z0, z1)) -> mark(z1)
a__tail(z0) -> tail(z0)
a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
a__sel(z0, z1) -> sel(z0, z1)
a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
a__take(z0, z1) -> take(z0, z1)
a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
a__afterNth(z0, z1) -> afterNth(z0, z1)
mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
mark(fst(z0)) -> a__fst(mark(z0))
mark(snd(z0)) -> a__snd(mark(z0))
mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
mark(head(z0)) -> a__head(mark(z0))
mark(tail(z0)) -> a__tail(mark(z0))
mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
mark(cons(z0, z1)) -> cons(mark(z0), z1)
mark(s(z0)) -> s(mark(z0))
mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
mark(0') -> 0'
mark(nil) -> nil

Types:
A__NATSFROM :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c:c1
c :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c:c1
MARK :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c1 :: c:c1
A__FST :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c2:c3
pair :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c2 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c2:c3
c3 :: c2:c3
A__SND :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c4:c5
c4 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c4:c5
c5 :: c4:c5
A__SPLITAT :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c6:c7:c8:c9
0' :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c6 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c6:c7:c8:c9
s :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
cons :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c7 :: c10:c11:c12 -> c6:c7:c8:c9 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c6:c7:c8:c9
A__U :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c10:c11:c12
a__splitAt :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
mark :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c8 :: c10:c11:c12 -> c6:c7:c8:c9 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c6:c7:c8:c9
c9 :: c6:c7:c8:c9
c10 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c10:c11:c12
c11 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c10:c11:c12
c12 :: c10:c11:c12
A__HEAD :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c13:c14
c13 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c13:c14
c14 :: c13:c14
A__TAIL :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c15:c16
c15 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c15:c16
c16 :: c15:c16
A__SEL :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c17:c18:c19
c17 :: c13:c14 -> c23:c24:c25 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c17:c18:c19
a__afterNth :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
A__AFTERNTH :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c23:c24:c25
c18 :: c13:c14 -> c23:c24:c25 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c17:c18:c19
c19 :: c17:c18:c19
A__TAKE :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c20:c21:c22
c20 :: c2:c3 -> c6:c7:c8:c9 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c20:c21:c22
c21 :: c2:c3 -> c6:c7:c8:c9 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c20:c21:c22
c22 :: c20:c21:c22
c23 :: c4:c5 -> c6:c7:c8:c9 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c23:c24:c25
c24 :: c4:c5 -> c6:c7:c8:c9 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c23:c24:c25
c25 :: c23:c24:c25
natsFrom :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c26 :: c:c1 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
fst :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c27 :: c2:c3 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
snd :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c28 :: c4:c5 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
splitAt :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c29 :: c6:c7:c8:c9 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c30 :: c6:c7:c8:c9 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
u :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c31 :: c10:c11:c12 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
head :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c32 :: c13:c14 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
tail :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c33 :: c15:c16 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
sel :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c34 :: c17:c18:c19 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c35 :: c17:c18:c19 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
afterNth :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c36 :: c23:c24:c25 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c37 :: c23:c24:c25 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
take :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c38 :: c20:c21:c22 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c39 :: c20:c21:c22 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c40 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c41 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c42 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c43 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c44 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
nil :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c45 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
a__natsFrom :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__fst :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__snd :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__u :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__head :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__tail :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__sel :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__take :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
hole_c:c11_46 :: c:c1
hole_pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil2_46 :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
hole_c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c453_46 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
hole_c2:c34_46 :: c2:c3
hole_c4:c55_46 :: c4:c5
hole_c6:c7:c8:c96_46 :: c6:c7:c8:c9
hole_c10:c11:c127_46 :: c10:c11:c12
hole_c13:c148_46 :: c13:c14
hole_c15:c169_46 :: c15:c16
hole_c17:c18:c1910_46 :: c17:c18:c19
hole_c23:c24:c2511_46 :: c23:c24:c25
hole_c20:c21:c2212_46 :: c20:c21:c22
gen_pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil13_46 :: Nat -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
gen_c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c4514_46 :: Nat -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
gen_c6:c7:c8:c915_46 :: Nat -> c6:c7:c8:c9


Generator Equations:
gen_pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil13_46(0) <=> 0'
gen_pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil13_46(+(x, 1)) <=> pair(0', gen_pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil13_46(x))
gen_c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c4514_46(0) <=> c44
gen_c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c4514_46(+(x, 1)) <=> c26(c(c44), gen_c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c4514_46(x))
gen_c6:c7:c8:c915_46(0) <=> c6(c44)
gen_c6:c7:c8:c915_46(+(x, 1)) <=> c7(c10(c44), gen_c6:c7:c8:c915_46(x), c44)


The following defined symbols remain to be analysed:
mark, A__NATSFROM, MARK, A__FST, A__SND, A__SPLITAT, A__U, a__splitAt, A__HEAD, A__TAIL, a__afterNth, a__natsFrom, a__fst, a__snd, a__u, a__head, a__tail

They will be analysed ascendingly in the following order:
A__NATSFROM = MARK
A__NATSFROM = A__FST
A__NATSFROM = A__SND
A__NATSFROM = A__SPLITAT
A__NATSFROM = A__U
A__NATSFROM = A__HEAD
A__NATSFROM = A__TAIL
MARK = A__FST
MARK = A__SND
MARK = A__SPLITAT
MARK = A__U
a__splitAt < MARK
mark < MARK
MARK = A__HEAD
MARK = A__TAIL
a__afterNth < MARK
A__FST = A__SND
A__FST = A__SPLITAT
A__FST = A__U
A__FST = A__HEAD
A__FST = A__TAIL
A__SND = A__SPLITAT
A__SND = A__U
A__SND = A__HEAD
A__SND = A__TAIL
A__SPLITAT = A__U
a__splitAt < A__SPLITAT
mark < A__SPLITAT
A__SPLITAT = A__HEAD
A__SPLITAT = A__TAIL
A__U = A__HEAD
A__U = A__TAIL
a__splitAt = mark
a__splitAt = a__afterNth
a__splitAt = a__natsFrom
a__splitAt = a__fst
a__splitAt = a__snd
a__splitAt = a__u
a__splitAt = a__head
a__splitAt = a__tail
mark = a__afterNth
mark = a__natsFrom
mark = a__fst
mark = a__snd
mark = a__u
mark = a__head
mark = a__tail
A__HEAD = A__TAIL
a__afterNth = a__natsFrom
a__afterNth = a__fst
a__afterNth = a__snd
a__afterNth = a__u
a__afterNth = a__head
a__afterNth = a__tail
a__natsFrom = a__fst
a__natsFrom = a__snd
a__natsFrom = a__u
a__natsFrom = a__head
a__natsFrom = a__tail
a__fst = a__snd
a__fst = a__u
a__fst = a__head
a__fst = a__tail
a__snd = a__u
a__snd = a__head
a__snd = a__tail
a__u = a__head
a__u = a__tail
a__head = a__tail

----------------------------------------

(17) RewriteLemmaProof (LOWER BOUND(ID))
Proved the following rewrite lemma:
mark(gen_pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil13_46(n17_46)) -> gen_pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil13_46(n17_46), rt in Omega(0)

Induction Base:
mark(gen_pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil13_46(0)) ->_R^Omega(0)
0'

Induction Step:
mark(gen_pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil13_46(+(n17_46, 1))) ->_R^Omega(0)
pair(mark(0'), mark(gen_pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil13_46(n17_46))) ->_R^Omega(0)
pair(0', mark(gen_pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil13_46(n17_46))) ->_IH
pair(0', gen_pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil13_46(c18_46))

We have rt in Omega(1) and sz in O(n). Thus, we have irc_R in Omega(n^0).
----------------------------------------

(18)
Obligation:
Innermost TRS:
Rules:
A__NATSFROM(z0) -> c(MARK(z0))
A__NATSFROM(z0) -> c1
A__FST(pair(z0, z1)) -> c2(MARK(z0))
A__FST(z0) -> c3
A__SND(pair(z0, z1)) -> c4(MARK(z1))
A__SND(z0) -> c5
A__SPLITAT(0', z0) -> c6(MARK(z0))
A__SPLITAT(s(z0), cons(z1, z2)) -> c7(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z0))
A__SPLITAT(s(z0), cons(z1, z2)) -> c8(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z2))
A__SPLITAT(z0, z1) -> c9
A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
A__U(z0, z1, z2, z3) -> c12
A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
A__HEAD(z0) -> c14
A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
A__TAIL(z0) -> c16
A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
A__SEL(z0, z1) -> c19
A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
A__TAKE(z0, z1) -> c22
A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
A__AFTERNTH(z0, z1) -> c25
MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
MARK(cons(z0, z1)) -> c40(MARK(z0))
MARK(s(z0)) -> c41(MARK(z0))
MARK(pair(z0, z1)) -> c42(MARK(z0))
MARK(pair(z0, z1)) -> c43(MARK(z1))
MARK(0') -> c44
MARK(nil) -> c45
a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
a__natsFrom(z0) -> natsFrom(z0)
a__fst(pair(z0, z1)) -> mark(z0)
a__fst(z0) -> fst(z0)
a__snd(pair(z0, z1)) -> mark(z1)
a__snd(z0) -> snd(z0)
a__splitAt(0', z0) -> pair(nil, mark(z0))
a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
a__splitAt(z0, z1) -> splitAt(z0, z1)
a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
a__head(cons(z0, z1)) -> mark(z0)
a__head(z0) -> head(z0)
a__tail(cons(z0, z1)) -> mark(z1)
a__tail(z0) -> tail(z0)
a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
a__sel(z0, z1) -> sel(z0, z1)
a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
a__take(z0, z1) -> take(z0, z1)
a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
a__afterNth(z0, z1) -> afterNth(z0, z1)
mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
mark(fst(z0)) -> a__fst(mark(z0))
mark(snd(z0)) -> a__snd(mark(z0))
mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
mark(head(z0)) -> a__head(mark(z0))
mark(tail(z0)) -> a__tail(mark(z0))
mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
mark(cons(z0, z1)) -> cons(mark(z0), z1)
mark(s(z0)) -> s(mark(z0))
mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
mark(0') -> 0'
mark(nil) -> nil

Types:
A__NATSFROM :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c:c1
c :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c:c1
MARK :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c1 :: c:c1
A__FST :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c2:c3
pair :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c2 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c2:c3
c3 :: c2:c3
A__SND :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c4:c5
c4 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c4:c5
c5 :: c4:c5
A__SPLITAT :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c6:c7:c8:c9
0' :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c6 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c6:c7:c8:c9
s :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
cons :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c7 :: c10:c11:c12 -> c6:c7:c8:c9 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c6:c7:c8:c9
A__U :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c10:c11:c12
a__splitAt :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
mark :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c8 :: c10:c11:c12 -> c6:c7:c8:c9 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c6:c7:c8:c9
c9 :: c6:c7:c8:c9
c10 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c10:c11:c12
c11 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c10:c11:c12
c12 :: c10:c11:c12
A__HEAD :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c13:c14
c13 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c13:c14
c14 :: c13:c14
A__TAIL :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c15:c16
c15 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c15:c16
c16 :: c15:c16
A__SEL :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c17:c18:c19
c17 :: c13:c14 -> c23:c24:c25 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c17:c18:c19
a__afterNth :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
A__AFTERNTH :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c23:c24:c25
c18 :: c13:c14 -> c23:c24:c25 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c17:c18:c19
c19 :: c17:c18:c19
A__TAKE :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c20:c21:c22
c20 :: c2:c3 -> c6:c7:c8:c9 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c20:c21:c22
c21 :: c2:c3 -> c6:c7:c8:c9 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c20:c21:c22
c22 :: c20:c21:c22
c23 :: c4:c5 -> c6:c7:c8:c9 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c23:c24:c25
c24 :: c4:c5 -> c6:c7:c8:c9 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c23:c24:c25
c25 :: c23:c24:c25
natsFrom :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c26 :: c:c1 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
fst :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c27 :: c2:c3 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
snd :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c28 :: c4:c5 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
splitAt :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c29 :: c6:c7:c8:c9 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c30 :: c6:c7:c8:c9 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
u :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c31 :: c10:c11:c12 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
head :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c32 :: c13:c14 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
tail :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c33 :: c15:c16 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
sel :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c34 :: c17:c18:c19 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c35 :: c17:c18:c19 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
afterNth :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c36 :: c23:c24:c25 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c37 :: c23:c24:c25 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
take :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c38 :: c20:c21:c22 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c39 :: c20:c21:c22 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c40 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c41 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c42 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c43 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
c44 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
nil :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c45 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
a__natsFrom :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__fst :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__snd :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__u :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__head :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__tail :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__sel :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__take :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
hole_c:c11_46 :: c:c1
hole_pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil2_46 :: pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
hole_c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c453_46 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
hole_c2:c34_46 :: c2:c3
hole_c4:c55_46 :: c4:c5
hole_c6:c7:c8:c96_46 :: c6:c7:c8:c9
hole_c10:c11:c127_46 :: c10:c11:c12
hole_c13:c148_46 :: c13:c14
hole_c15:c169_46 :: c15:c16
hole_c17:c18:c1910_46 :: c17:c18:c19
hole_c23:c24:c2511_46 :: c23:c24:c25
hole_c20:c21:c2212_46 :: c20:c21:c22
gen_pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil13_46 :: Nat -> pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
gen_c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c4514_46 :: Nat -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c45
gen_c6:c7:c8:c915_46 :: Nat -> c6:c7:c8:c9


Lemmas:
mark(gen_pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil13_46(n17_46)) -> gen_pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil13_46(n17_46), rt in Omega(0)


Generator Equations:
gen_pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil13_46(0) <=> 0'
gen_pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil13_46(+(x, 1)) <=> pair(0', gen_pair:0':s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil13_46(x))
gen_c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c4514_46(0) <=> c44
gen_c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c4514_46(+(x, 1)) <=> c26(c(c44), gen_c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:c44:c4514_46(x))
gen_c6:c7:c8:c915_46(0) <=> c6(c44)
gen_c6:c7:c8:c915_46(+(x, 1)) <=> c7(c10(c44), gen_c6:c7:c8:c915_46(x), c44)


The following defined symbols remain to be analysed:
a__natsFrom, A__NATSFROM, MARK, A__FST, A__SND, A__SPLITAT, A__U, a__splitAt, A__HEAD, A__TAIL, a__afterNth, a__fst, a__snd, a__u, a__head, a__tail

They will be analysed ascendingly in the following order:
A__NATSFROM = MARK
A__NATSFROM = A__FST
A__NATSFROM = A__SND
A__NATSFROM = A__SPLITAT
A__NATSFROM = A__U
A__NATSFROM = A__HEAD
A__NATSFROM = A__TAIL
MARK = A__FST
MARK = A__SND
MARK = A__SPLITAT
MARK = A__U
a__splitAt < MARK
mark < MARK
MARK = A__HEAD
MARK = A__TAIL
a__afterNth < MARK
A__FST = A__SND
A__FST = A__SPLITAT
A__FST = A__U
A__FST = A__HEAD
A__FST = A__TAIL
A__SND = A__SPLITAT
A__SND = A__U
A__SND = A__HEAD
A__SND = A__TAIL
A__SPLITAT = A__U
a__splitAt < A__SPLITAT
mark < A__SPLITAT
A__SPLITAT = A__HEAD
A__SPLITAT = A__TAIL
A__U = A__HEAD
A__U = A__TAIL
a__splitAt = mark
a__splitAt = a__afterNth
a__splitAt = a__natsFrom
a__splitAt = a__fst
a__splitAt = a__snd
a__splitAt = a__u
a__splitAt = a__head
a__splitAt = a__tail
mark = a__afterNth
mark = a__natsFrom
mark = a__fst
mark = a__snd
mark = a__u
mark = a__head
mark = a__tail
A__HEAD = A__TAIL
a__afterNth = a__natsFrom
a__afterNth = a__fst
a__afterNth = a__snd
a__afterNth = a__u
a__afterNth = a__head
a__afterNth = a__tail
a__natsFrom = a__fst
a__natsFrom = a__snd
a__natsFrom = a__u
a__natsFrom = a__head
a__natsFrom = a__tail
a__fst = a__snd
a__fst = a__u
a__fst = a__head
a__fst = a__tail
a__snd = a__u
a__snd = a__head
a__snd = a__tail
a__u = a__head
a__u = a__tail
a__head = a__tail

----------------------------------------

(19) RelTrsToWeightedTrsProof (UPPER BOUND(ID))
Transformed relative TRS to weighted TRS
----------------------------------------

(20)
Obligation:
The Runtime Complexity (innermost) of the given CpxWeightedTrs could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   a__natsFrom(N) -> cons(mark(N), natsFrom(s(N))) [1]
   a__fst(pair(XS, YS)) -> mark(XS) [1]
   a__snd(pair(XS, YS)) -> mark(YS) [1]
   a__splitAt(0, XS) -> pair(nil, mark(XS)) [1]
   a__splitAt(s(N), cons(X, XS)) -> a__u(a__splitAt(mark(N), mark(XS)), N, X, XS) [1]
   a__u(pair(YS, ZS), N, X, XS) -> pair(cons(mark(X), YS), mark(ZS)) [1]
   a__head(cons(N, XS)) -> mark(N) [1]
   a__tail(cons(N, XS)) -> mark(XS) [1]
   a__sel(N, XS) -> a__head(a__afterNth(mark(N), mark(XS))) [1]
   a__take(N, XS) -> a__fst(a__splitAt(mark(N), mark(XS))) [1]
   a__afterNth(N, XS) -> a__snd(a__splitAt(mark(N), mark(XS))) [1]
   mark(natsFrom(X)) -> a__natsFrom(mark(X)) [1]
   mark(fst(X)) -> a__fst(mark(X)) [1]
   mark(snd(X)) -> a__snd(mark(X)) [1]
   mark(splitAt(X1, X2)) -> a__splitAt(mark(X1), mark(X2)) [1]
   mark(u(X1, X2, X3, X4)) -> a__u(mark(X1), X2, X3, X4) [1]
   mark(head(X)) -> a__head(mark(X)) [1]
   mark(tail(X)) -> a__tail(mark(X)) [1]
   mark(sel(X1, X2)) -> a__sel(mark(X1), mark(X2)) [1]
   mark(afterNth(X1, X2)) -> a__afterNth(mark(X1), mark(X2)) [1]
   mark(take(X1, X2)) -> a__take(mark(X1), mark(X2)) [1]
   mark(cons(X1, X2)) -> cons(mark(X1), X2) [1]
   mark(s(X)) -> s(mark(X)) [1]
   mark(pair(X1, X2)) -> pair(mark(X1), mark(X2)) [1]
   mark(0) -> 0 [1]
   mark(nil) -> nil [1]
   a__natsFrom(X) -> natsFrom(X) [1]
   a__fst(X) -> fst(X) [1]
   a__snd(X) -> snd(X) [1]
   a__splitAt(X1, X2) -> splitAt(X1, X2) [1]
   a__u(X1, X2, X3, X4) -> u(X1, X2, X3, X4) [1]
   a__head(X) -> head(X) [1]
   a__tail(X) -> tail(X) [1]
   a__sel(X1, X2) -> sel(X1, X2) [1]
   a__afterNth(X1, X2) -> afterNth(X1, X2) [1]
   a__take(X1, X2) -> take(X1, X2) [1]

Rewrite Strategy: INNERMOST
----------------------------------------

(21) TypeInferenceProof (BOTH BOUNDS(ID, ID))
Infered types.
----------------------------------------

(22)
Obligation:
Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   a__natsFrom(N) -> cons(mark(N), natsFrom(s(N))) [1]
   a__fst(pair(XS, YS)) -> mark(XS) [1]
   a__snd(pair(XS, YS)) -> mark(YS) [1]
   a__splitAt(0, XS) -> pair(nil, mark(XS)) [1]
   a__splitAt(s(N), cons(X, XS)) -> a__u(a__splitAt(mark(N), mark(XS)), N, X, XS) [1]
   a__u(pair(YS, ZS), N, X, XS) -> pair(cons(mark(X), YS), mark(ZS)) [1]
   a__head(cons(N, XS)) -> mark(N) [1]
   a__tail(cons(N, XS)) -> mark(XS) [1]
   a__sel(N, XS) -> a__head(a__afterNth(mark(N), mark(XS))) [1]
   a__take(N, XS) -> a__fst(a__splitAt(mark(N), mark(XS))) [1]
   a__afterNth(N, XS) -> a__snd(a__splitAt(mark(N), mark(XS))) [1]
   mark(natsFrom(X)) -> a__natsFrom(mark(X)) [1]
   mark(fst(X)) -> a__fst(mark(X)) [1]
   mark(snd(X)) -> a__snd(mark(X)) [1]
   mark(splitAt(X1, X2)) -> a__splitAt(mark(X1), mark(X2)) [1]
   mark(u(X1, X2, X3, X4)) -> a__u(mark(X1), X2, X3, X4) [1]
   mark(head(X)) -> a__head(mark(X)) [1]
   mark(tail(X)) -> a__tail(mark(X)) [1]
   mark(sel(X1, X2)) -> a__sel(mark(X1), mark(X2)) [1]
   mark(afterNth(X1, X2)) -> a__afterNth(mark(X1), mark(X2)) [1]
   mark(take(X1, X2)) -> a__take(mark(X1), mark(X2)) [1]
   mark(cons(X1, X2)) -> cons(mark(X1), X2) [1]
   mark(s(X)) -> s(mark(X)) [1]
   mark(pair(X1, X2)) -> pair(mark(X1), mark(X2)) [1]
   mark(0) -> 0 [1]
   mark(nil) -> nil [1]
   a__natsFrom(X) -> natsFrom(X) [1]
   a__fst(X) -> fst(X) [1]
   a__snd(X) -> snd(X) [1]
   a__splitAt(X1, X2) -> splitAt(X1, X2) [1]
   a__u(X1, X2, X3, X4) -> u(X1, X2, X3, X4) [1]
   a__head(X) -> head(X) [1]
   a__tail(X) -> tail(X) [1]
   a__sel(X1, X2) -> sel(X1, X2) [1]
   a__afterNth(X1, X2) -> afterNth(X1, X2) [1]
   a__take(X1, X2) -> take(X1, X2) [1]

The TRS has the following type information:
a__natsFrom :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
cons :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
mark :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
natsFrom :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
s :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__fst :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
pair :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__snd :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__splitAt :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
0 :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
nil :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__u :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__head :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__tail :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__sel :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__afterNth :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__take :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
fst :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
snd :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
splitAt :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
u :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
head :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
tail :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
sel :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
afterNth :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
take :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take

Rewrite Strategy: INNERMOST
----------------------------------------

(23) CompletionProof (UPPER BOUND(ID))
The transformation into a RNTS is sound, since:

(a) The obligation is a constructor system where every type has a constant constructor,

(b) The following defined symbols do not have to be completely defined, as they can never occur inside other defined symbols:
none

(c) The following functions are completely defined:

   a__splitAt_2
   mark_1
   a__afterNth_2
   a__fst_1
   a__u_4
   a__tail_1
   a__snd_1
   a__take_2
   a__sel_2
   a__natsFrom_1
   a__head_1

Due to the following rules being added:
none

And the following fresh constants: none

----------------------------------------

(24)
Obligation:
Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   a__natsFrom(N) -> cons(mark(N), natsFrom(s(N))) [1]
   a__fst(pair(XS, YS)) -> mark(XS) [1]
   a__snd(pair(XS, YS)) -> mark(YS) [1]
   a__splitAt(0, XS) -> pair(nil, mark(XS)) [1]
   a__splitAt(s(N), cons(X, XS)) -> a__u(a__splitAt(mark(N), mark(XS)), N, X, XS) [1]
   a__u(pair(YS, ZS), N, X, XS) -> pair(cons(mark(X), YS), mark(ZS)) [1]
   a__head(cons(N, XS)) -> mark(N) [1]
   a__tail(cons(N, XS)) -> mark(XS) [1]
   a__sel(N, XS) -> a__head(a__afterNth(mark(N), mark(XS))) [1]
   a__take(N, XS) -> a__fst(a__splitAt(mark(N), mark(XS))) [1]
   a__afterNth(N, XS) -> a__snd(a__splitAt(mark(N), mark(XS))) [1]
   mark(natsFrom(X)) -> a__natsFrom(mark(X)) [1]
   mark(fst(X)) -> a__fst(mark(X)) [1]
   mark(snd(X)) -> a__snd(mark(X)) [1]
   mark(splitAt(X1, X2)) -> a__splitAt(mark(X1), mark(X2)) [1]
   mark(u(X1, X2, X3, X4)) -> a__u(mark(X1), X2, X3, X4) [1]
   mark(head(X)) -> a__head(mark(X)) [1]
   mark(tail(X)) -> a__tail(mark(X)) [1]
   mark(sel(X1, X2)) -> a__sel(mark(X1), mark(X2)) [1]
   mark(afterNth(X1, X2)) -> a__afterNth(mark(X1), mark(X2)) [1]
   mark(take(X1, X2)) -> a__take(mark(X1), mark(X2)) [1]
   mark(cons(X1, X2)) -> cons(mark(X1), X2) [1]
   mark(s(X)) -> s(mark(X)) [1]
   mark(pair(X1, X2)) -> pair(mark(X1), mark(X2)) [1]
   mark(0) -> 0 [1]
   mark(nil) -> nil [1]
   a__natsFrom(X) -> natsFrom(X) [1]
   a__fst(X) -> fst(X) [1]
   a__snd(X) -> snd(X) [1]
   a__splitAt(X1, X2) -> splitAt(X1, X2) [1]
   a__u(X1, X2, X3, X4) -> u(X1, X2, X3, X4) [1]
   a__head(X) -> head(X) [1]
   a__tail(X) -> tail(X) [1]
   a__sel(X1, X2) -> sel(X1, X2) [1]
   a__afterNth(X1, X2) -> afterNth(X1, X2) [1]
   a__take(X1, X2) -> take(X1, X2) [1]

The TRS has the following type information:
a__natsFrom :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
cons :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
mark :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
natsFrom :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
s :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__fst :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
pair :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__snd :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__splitAt :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
0 :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
nil :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__u :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__head :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__tail :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__sel :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__afterNth :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__take :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
fst :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
snd :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
splitAt :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
u :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
head :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
tail :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
sel :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
afterNth :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
take :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take

Rewrite Strategy: INNERMOST
----------------------------------------

(25) NarrowingProof (BOTH BOUNDS(ID, ID))
Narrowed the inner basic terms of all right-hand sides by a single narrowing step.
----------------------------------------

(26)
Obligation:
Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   a__natsFrom(N) -> cons(mark(N), natsFrom(s(N))) [1]
   a__fst(pair(XS, YS)) -> mark(XS) [1]
   a__snd(pair(XS, YS)) -> mark(YS) [1]
   a__splitAt(0, XS) -> pair(nil, mark(XS)) [1]
   a__splitAt(s(N), cons(X, XS)) -> a__u(a__splitAt(mark(N), mark(XS)), N, X, XS) [1]
   a__u(pair(YS, ZS), N, X, XS) -> pair(cons(mark(X), YS), mark(ZS)) [1]
   a__head(cons(N, XS)) -> mark(N) [1]
   a__tail(cons(N, XS)) -> mark(XS) [1]
   a__sel(N, XS) -> a__head(a__afterNth(mark(N), mark(XS))) [1]
   a__take(N, XS) -> a__fst(a__splitAt(mark(N), mark(XS))) [1]
   a__afterNth(N, XS) -> a__snd(a__splitAt(mark(N), mark(XS))) [1]
   mark(natsFrom(natsFrom(X647))) -> a__natsFrom(a__natsFrom(mark(X647))) [2]
   mark(natsFrom(fst(X648))) -> a__natsFrom(a__fst(mark(X648))) [2]
   mark(natsFrom(snd(X649))) -> a__natsFrom(a__snd(mark(X649))) [2]
   mark(natsFrom(splitAt(X1449, X2447))) -> a__natsFrom(a__splitAt(mark(X1449), mark(X2447))) [2]
   mark(natsFrom(u(X1450, X2448, X3135, X4125))) -> a__natsFrom(a__u(mark(X1450), X2448, X3135, X4125)) [2]
   mark(natsFrom(head(X650))) -> a__natsFrom(a__head(mark(X650))) [2]
   mark(natsFrom(tail(X651))) -> a__natsFrom(a__tail(mark(X651))) [2]
   mark(natsFrom(sel(X1451, X2449))) -> a__natsFrom(a__sel(mark(X1451), mark(X2449))) [2]
   mark(natsFrom(afterNth(X1452, X2450))) -> a__natsFrom(a__afterNth(mark(X1452), mark(X2450))) [2]
   mark(natsFrom(take(X1453, X2451))) -> a__natsFrom(a__take(mark(X1453), mark(X2451))) [2]
   mark(natsFrom(cons(X1454, X2452))) -> a__natsFrom(cons(mark(X1454), X2452)) [2]
   mark(natsFrom(s(X652))) -> a__natsFrom(s(mark(X652))) [2]
   mark(natsFrom(pair(X1455, X2453))) -> a__natsFrom(pair(mark(X1455), mark(X2453))) [2]
   mark(natsFrom(0)) -> a__natsFrom(0) [2]
   mark(natsFrom(nil)) -> a__natsFrom(nil) [2]
   mark(fst(natsFrom(X653))) -> a__fst(a__natsFrom(mark(X653))) [2]
   mark(fst(fst(X654))) -> a__fst(a__fst(mark(X654))) [2]
   mark(fst(snd(X655))) -> a__fst(a__snd(mark(X655))) [2]
   mark(fst(splitAt(X1456, X2454))) -> a__fst(a__splitAt(mark(X1456), mark(X2454))) [2]
   mark(fst(u(X1457, X2455, X3136, X4126))) -> a__fst(a__u(mark(X1457), X2455, X3136, X4126)) [2]
   mark(fst(head(X656))) -> a__fst(a__head(mark(X656))) [2]
   mark(fst(tail(X657))) -> a__fst(a__tail(mark(X657))) [2]
   mark(fst(sel(X1458, X2456))) -> a__fst(a__sel(mark(X1458), mark(X2456))) [2]
   mark(fst(afterNth(X1459, X2457))) -> a__fst(a__afterNth(mark(X1459), mark(X2457))) [2]
   mark(fst(take(X1460, X2458))) -> a__fst(a__take(mark(X1460), mark(X2458))) [2]
   mark(fst(cons(X1461, X2459))) -> a__fst(cons(mark(X1461), X2459)) [2]
   mark(fst(s(X658))) -> a__fst(s(mark(X658))) [2]
   mark(fst(pair(X1462, X2460))) -> a__fst(pair(mark(X1462), mark(X2460))) [2]
   mark(fst(0)) -> a__fst(0) [2]
   mark(fst(nil)) -> a__fst(nil) [2]
   mark(snd(natsFrom(X659))) -> a__snd(a__natsFrom(mark(X659))) [2]
   mark(snd(fst(X660))) -> a__snd(a__fst(mark(X660))) [2]
   mark(snd(snd(X661))) -> a__snd(a__snd(mark(X661))) [2]
   mark(snd(splitAt(X1463, X2461))) -> a__snd(a__splitAt(mark(X1463), mark(X2461))) [2]
   mark(snd(u(X1464, X2462, X3137, X4127))) -> a__snd(a__u(mark(X1464), X2462, X3137, X4127)) [2]
   mark(snd(head(X662))) -> a__snd(a__head(mark(X662))) [2]
   mark(snd(tail(X663))) -> a__snd(a__tail(mark(X663))) [2]
   mark(snd(sel(X1465, X2463))) -> a__snd(a__sel(mark(X1465), mark(X2463))) [2]
   mark(snd(afterNth(X1466, X2464))) -> a__snd(a__afterNth(mark(X1466), mark(X2464))) [2]
   mark(snd(take(X1467, X2465))) -> a__snd(a__take(mark(X1467), mark(X2465))) [2]
   mark(snd(cons(X1468, X2466))) -> a__snd(cons(mark(X1468), X2466)) [2]
   mark(snd(s(X664))) -> a__snd(s(mark(X664))) [2]
   mark(snd(pair(X1469, X2467))) -> a__snd(pair(mark(X1469), mark(X2467))) [2]
   mark(snd(0)) -> a__snd(0) [2]
   mark(snd(nil)) -> a__snd(nil) [2]
   mark(splitAt(X1, X2)) -> a__splitAt(mark(X1), mark(X2)) [1]
   mark(u(natsFrom(X761), X2, X3, X4)) -> a__u(a__natsFrom(mark(X761)), X2, X3, X4) [2]
   mark(u(fst(X762), X2, X3, X4)) -> a__u(a__fst(mark(X762)), X2, X3, X4) [2]
   mark(u(snd(X763), X2, X3, X4)) -> a__u(a__snd(mark(X763)), X2, X3, X4) [2]
   mark(u(splitAt(X1582, X2580), X2, X3, X4)) -> a__u(a__splitAt(mark(X1582), mark(X2580)), X2, X3, X4) [2]
   mark(u(u(X1583, X2581, X3154, X4144), X2, X3, X4)) -> a__u(a__u(mark(X1583), X2581, X3154, X4144), X2, X3, X4) [2]
   mark(u(head(X764), X2, X3, X4)) -> a__u(a__head(mark(X764)), X2, X3, X4) [2]
   mark(u(tail(X765), X2, X3, X4)) -> a__u(a__tail(mark(X765)), X2, X3, X4) [2]
   mark(u(sel(X1584, X2582), X2, X3, X4)) -> a__u(a__sel(mark(X1584), mark(X2582)), X2, X3, X4) [2]
   mark(u(afterNth(X1585, X2583), X2, X3, X4)) -> a__u(a__afterNth(mark(X1585), mark(X2583)), X2, X3, X4) [2]
   mark(u(take(X1586, X2584), X2, X3, X4)) -> a__u(a__take(mark(X1586), mark(X2584)), X2, X3, X4) [2]
   mark(u(cons(X1587, X2585), X2, X3, X4)) -> a__u(cons(mark(X1587), X2585), X2, X3, X4) [2]
   mark(u(s(X766), X2, X3, X4)) -> a__u(s(mark(X766)), X2, X3, X4) [2]
   mark(u(pair(X1588, X2586), X2, X3, X4)) -> a__u(pair(mark(X1588), mark(X2586)), X2, X3, X4) [2]
   mark(u(0, X2, X3, X4)) -> a__u(0, X2, X3, X4) [2]
   mark(u(nil, X2, X3, X4)) -> a__u(nil, X2, X3, X4) [2]
   mark(head(natsFrom(X767))) -> a__head(a__natsFrom(mark(X767))) [2]
   mark(head(fst(X768))) -> a__head(a__fst(mark(X768))) [2]
   mark(head(snd(X769))) -> a__head(a__snd(mark(X769))) [2]
   mark(head(splitAt(X1589, X2587))) -> a__head(a__splitAt(mark(X1589), mark(X2587))) [2]
   mark(head(u(X1590, X2588, X3155, X4145))) -> a__head(a__u(mark(X1590), X2588, X3155, X4145)) [2]
   mark(head(head(X770))) -> a__head(a__head(mark(X770))) [2]
   mark(head(tail(X771))) -> a__head(a__tail(mark(X771))) [2]
   mark(head(sel(X1591, X2589))) -> a__head(a__sel(mark(X1591), mark(X2589))) [2]
   mark(head(afterNth(X1592, X2590))) -> a__head(a__afterNth(mark(X1592), mark(X2590))) [2]
   mark(head(take(X1593, X2591))) -> a__head(a__take(mark(X1593), mark(X2591))) [2]
   mark(head(cons(X1594, X2592))) -> a__head(cons(mark(X1594), X2592)) [2]
   mark(head(s(X772))) -> a__head(s(mark(X772))) [2]
   mark(head(pair(X1595, X2593))) -> a__head(pair(mark(X1595), mark(X2593))) [2]
   mark(head(0)) -> a__head(0) [2]
   mark(head(nil)) -> a__head(nil) [2]
   mark(tail(natsFrom(X773))) -> a__tail(a__natsFrom(mark(X773))) [2]
   mark(tail(fst(X774))) -> a__tail(a__fst(mark(X774))) [2]
   mark(tail(snd(X775))) -> a__tail(a__snd(mark(X775))) [2]
   mark(tail(splitAt(X1596, X2594))) -> a__tail(a__splitAt(mark(X1596), mark(X2594))) [2]
   mark(tail(u(X1597, X2595, X3156, X4146))) -> a__tail(a__u(mark(X1597), X2595, X3156, X4146)) [2]
   mark(tail(head(X776))) -> a__tail(a__head(mark(X776))) [2]
   mark(tail(tail(X777))) -> a__tail(a__tail(mark(X777))) [2]
   mark(tail(sel(X1598, X2596))) -> a__tail(a__sel(mark(X1598), mark(X2596))) [2]
   mark(tail(afterNth(X1599, X2597))) -> a__tail(a__afterNth(mark(X1599), mark(X2597))) [2]
   mark(tail(take(X1600, X2598))) -> a__tail(a__take(mark(X1600), mark(X2598))) [2]
   mark(tail(cons(X1601, X2599))) -> a__tail(cons(mark(X1601), X2599)) [2]
   mark(tail(s(X778))) -> a__tail(s(mark(X778))) [2]
   mark(tail(pair(X1602, X2600))) -> a__tail(pair(mark(X1602), mark(X2600))) [2]
   mark(tail(0)) -> a__tail(0) [2]
   mark(tail(nil)) -> a__tail(nil) [2]
   mark(sel(X1, X2)) -> a__sel(mark(X1), mark(X2)) [1]
   mark(afterNth(X1, X2)) -> a__afterNth(mark(X1), mark(X2)) [1]
   mark(take(X1, X2)) -> a__take(mark(X1), mark(X2)) [1]
   mark(cons(X1, X2)) -> cons(mark(X1), X2) [1]
   mark(s(X)) -> s(mark(X)) [1]
   mark(pair(X1, X2)) -> pair(mark(X1), mark(X2)) [1]
   mark(0) -> 0 [1]
   mark(nil) -> nil [1]
   a__natsFrom(X) -> natsFrom(X) [1]
   a__fst(X) -> fst(X) [1]
   a__snd(X) -> snd(X) [1]
   a__splitAt(X1, X2) -> splitAt(X1, X2) [1]
   a__u(X1, X2, X3, X4) -> u(X1, X2, X3, X4) [1]
   a__head(X) -> head(X) [1]
   a__tail(X) -> tail(X) [1]
   a__sel(X1, X2) -> sel(X1, X2) [1]
   a__afterNth(X1, X2) -> afterNth(X1, X2) [1]
   a__take(X1, X2) -> take(X1, X2) [1]

The TRS has the following type information:
a__natsFrom :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
cons :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
mark :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
natsFrom :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
s :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__fst :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
pair :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__snd :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__splitAt :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
0 :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
nil :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__u :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__head :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__tail :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__sel :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__afterNth :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__take :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
fst :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
snd :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
splitAt :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
u :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
head :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
tail :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
sel :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
afterNth :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
take :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take

Rewrite Strategy: INNERMOST
----------------------------------------

(27) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID))
Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction.
The constant constructors are abstracted as follows:

   0 => 0
   nil => 1

----------------------------------------

(28)
Obligation:
Complexity RNTS consisting of the following rules:

   a__afterNth(z, z') -{ 1 }-> a__snd(a__splitAt(mark(N), mark(XS))) :|: z' = XS, z = N, XS >= 0, N >= 0
   a__afterNth(z, z') -{ 1 }-> 1 + X1 + X2 :|: X1 >= 0, X2 >= 0, z = X1, z' = X2
   a__fst(z) -{ 1 }-> mark(XS) :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   a__fst(z) -{ 1 }-> 1 + X :|: X >= 0, z = X
   a__head(z) -{ 1 }-> mark(N) :|: z = 1 + N + XS, XS >= 0, N >= 0
   a__head(z) -{ 1 }-> 1 + X :|: X >= 0, z = X
   a__natsFrom(z) -{ 1 }-> 1 + X :|: X >= 0, z = X
   a__natsFrom(z) -{ 1 }-> 1 + mark(N) + (1 + (1 + N)) :|: z = N, N >= 0
   a__sel(z, z') -{ 1 }-> a__head(a__afterNth(mark(N), mark(XS))) :|: z' = XS, z = N, XS >= 0, N >= 0
   a__sel(z, z') -{ 1 }-> 1 + X1 + X2 :|: X1 >= 0, X2 >= 0, z = X1, z' = X2
   a__snd(z) -{ 1 }-> mark(YS) :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   a__snd(z) -{ 1 }-> 1 + X :|: X >= 0, z = X
   a__splitAt(z, z') -{ 1 }-> a__u(a__splitAt(mark(N), mark(XS)), N, X, XS) :|: z = 1 + N, z' = 1 + X + XS, X >= 0, XS >= 0, N >= 0
   a__splitAt(z, z') -{ 1 }-> 1 + X1 + X2 :|: X1 >= 0, X2 >= 0, z = X1, z' = X2
   a__splitAt(z, z') -{ 1 }-> 1 + 1 + mark(XS) :|: z' = XS, z = 0, XS >= 0
   a__tail(z) -{ 1 }-> mark(XS) :|: z = 1 + N + XS, XS >= 0, N >= 0
   a__tail(z) -{ 1 }-> 1 + X :|: X >= 0, z = X
   a__take(z, z') -{ 1 }-> a__fst(a__splitAt(mark(N), mark(XS))) :|: z' = XS, z = N, XS >= 0, N >= 0
   a__take(z, z') -{ 1 }-> 1 + X1 + X2 :|: X1 >= 0, X2 >= 0, z = X1, z' = X2
   a__u(z, z', z'', z1) -{ 1 }-> 1 + (1 + mark(X) + YS) + mark(ZS) :|: z = 1 + YS + ZS, z'' = X, YS >= 0, X >= 0, z' = N, z1 = XS, ZS >= 0, XS >= 0, N >= 0
   a__u(z, z', z'', z1) -{ 1 }-> 1 + X1 + X2 + X3 + X4 :|: X1 >= 0, z1 = X4, X3 >= 0, X2 >= 0, X4 >= 0, z = X1, z' = X2, z'' = X3
   mark(z) -{ 2 }-> a__u(a__u(mark(X1583), X2581, X3154, X4144), X2, X3, X4) :|: X4144 >= 0, X1583 >= 0, X3154 >= 0, X3 >= 0, z = 1 + (1 + X1583 + X2581 + X3154 + X4144) + X2 + X3 + X4, X2 >= 0, X4 >= 0, X2581 >= 0
   mark(z) -{ 2 }-> a__u(a__take(mark(X1586), mark(X2584)), X2, X3, X4) :|: z = 1 + (1 + X1586 + X2584) + X2 + X3 + X4, X2584 >= 0, X3 >= 0, X1586 >= 0, X2 >= 0, X4 >= 0
   mark(z) -{ 2 }-> a__u(a__tail(mark(X765)), X2, X3, X4) :|: X765 >= 0, X3 >= 0, z = 1 + (1 + X765) + X2 + X3 + X4, X2 >= 0, X4 >= 0
   mark(z) -{ 2 }-> a__u(a__splitAt(mark(X1582), mark(X2580)), X2, X3, X4) :|: z = 1 + (1 + X1582 + X2580) + X2 + X3 + X4, X3 >= 0, X1582 >= 0, X2 >= 0, X4 >= 0, X2580 >= 0
   mark(z) -{ 2 }-> a__u(a__snd(mark(X763)), X2, X3, X4) :|: X763 >= 0, X3 >= 0, X2 >= 0, X4 >= 0, z = 1 + (1 + X763) + X2 + X3 + X4
   mark(z) -{ 2 }-> a__u(a__sel(mark(X1584), mark(X2582)), X2, X3, X4) :|: z = 1 + (1 + X1584 + X2582) + X2 + X3 + X4, X1584 >= 0, X2582 >= 0, X3 >= 0, X2 >= 0, X4 >= 0
   mark(z) -{ 2 }-> a__u(a__natsFrom(mark(X761)), X2, X3, X4) :|: X3 >= 0, z = 1 + (1 + X761) + X2 + X3 + X4, X2 >= 0, X4 >= 0, X761 >= 0
   mark(z) -{ 2 }-> a__u(a__head(mark(X764)), X2, X3, X4) :|: z = 1 + (1 + X764) + X2 + X3 + X4, X764 >= 0, X3 >= 0, X2 >= 0, X4 >= 0
   mark(z) -{ 2 }-> a__u(a__fst(mark(X762)), X2, X3, X4) :|: z = 1 + (1 + X762) + X2 + X3 + X4, X3 >= 0, X2 >= 0, X4 >= 0, X762 >= 0
   mark(z) -{ 2 }-> a__u(a__afterNth(mark(X1585), mark(X2583)), X2, X3, X4) :|: X2583 >= 0, X3 >= 0, z = 1 + (1 + X1585 + X2583) + X2 + X3 + X4, X2 >= 0, X4 >= 0, X1585 >= 0
   mark(z) -{ 2 }-> a__u(1, X2, X3, X4) :|: X3 >= 0, X2 >= 0, X4 >= 0, z = 1 + 1 + X2 + X3 + X4
   mark(z) -{ 2 }-> a__u(0, X2, X3, X4) :|: X3 >= 0, z = 1 + 0 + X2 + X3 + X4, X2 >= 0, X4 >= 0
   mark(z) -{ 2 }-> a__u(1 + mark(X766), X2, X3, X4) :|: X766 >= 0, X3 >= 0, X2 >= 0, X4 >= 0, z = 1 + (1 + X766) + X2 + X3 + X4
   mark(z) -{ 2 }-> a__u(1 + mark(X1587) + X2585, X2, X3, X4) :|: X1587 >= 0, X2585 >= 0, X3 >= 0, z = 1 + (1 + X1587 + X2585) + X2 + X3 + X4, X2 >= 0, X4 >= 0
   mark(z) -{ 2 }-> a__u(1 + mark(X1588) + mark(X2586), X2, X3, X4) :|: X1588 >= 0, X2586 >= 0, X3 >= 0, z = 1 + (1 + X1588 + X2586) + X2 + X3 + X4, X2 >= 0, X4 >= 0
   mark(z) -{ 1 }-> a__take(mark(X1), mark(X2)) :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2
   mark(z) -{ 2 }-> a__tail(a__u(mark(X1597), X2595, X3156, X4146)) :|: z = 1 + (1 + X1597 + X2595 + X3156 + X4146), X3156 >= 0, X2595 >= 0, X4146 >= 0, X1597 >= 0
   mark(z) -{ 2 }-> a__tail(a__take(mark(X1600), mark(X2598))) :|: X1600 >= 0, z = 1 + (1 + X1600 + X2598), X2598 >= 0
   mark(z) -{ 2 }-> a__tail(a__tail(mark(X777))) :|: z = 1 + (1 + X777), X777 >= 0
   mark(z) -{ 2 }-> a__tail(a__splitAt(mark(X1596), mark(X2594))) :|: X2594 >= 0, X1596 >= 0, z = 1 + (1 + X1596 + X2594)
   mark(z) -{ 2 }-> a__tail(a__snd(mark(X775))) :|: X775 >= 0, z = 1 + (1 + X775)
   mark(z) -{ 2 }-> a__tail(a__sel(mark(X1598), mark(X2596))) :|: z = 1 + (1 + X1598 + X2596), X1598 >= 0, X2596 >= 0
   mark(z) -{ 2 }-> a__tail(a__natsFrom(mark(X773))) :|: z = 1 + (1 + X773), X773 >= 0
   mark(z) -{ 2 }-> a__tail(a__head(mark(X776))) :|: z = 1 + (1 + X776), X776 >= 0
   mark(z) -{ 2 }-> a__tail(a__fst(mark(X774))) :|: X774 >= 0, z = 1 + (1 + X774)
   mark(z) -{ 2 }-> a__tail(a__afterNth(mark(X1599), mark(X2597))) :|: X1599 >= 0, z = 1 + (1 + X1599 + X2597), X2597 >= 0
   mark(z) -{ 2 }-> a__tail(1) :|: z = 1 + 1
   mark(z) -{ 2 }-> a__tail(0) :|: z = 1 + 0
   mark(z) -{ 2 }-> a__tail(1 + mark(X778)) :|: X778 >= 0, z = 1 + (1 + X778)
   mark(z) -{ 2 }-> a__tail(1 + mark(X1601) + X2599) :|: z = 1 + (1 + X1601 + X2599), X1601 >= 0, X2599 >= 0
   mark(z) -{ 2 }-> a__tail(1 + mark(X1602) + mark(X2600)) :|: X1602 >= 0, X2600 >= 0, z = 1 + (1 + X1602 + X2600)
   mark(z) -{ 1 }-> a__splitAt(mark(X1), mark(X2)) :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2
   mark(z) -{ 2 }-> a__snd(a__u(mark(X1464), X2462, X3137, X4127)) :|: X1464 >= 0, X2462 >= 0, z = 1 + (1 + X1464 + X2462 + X3137 + X4127), X4127 >= 0, X3137 >= 0
   mark(z) -{ 2 }-> a__snd(a__take(mark(X1467), mark(X2465))) :|: z = 1 + (1 + X1467 + X2465), X2465 >= 0, X1467 >= 0
   mark(z) -{ 2 }-> a__snd(a__tail(mark(X663))) :|: z = 1 + (1 + X663), X663 >= 0
   mark(z) -{ 2 }-> a__snd(a__splitAt(mark(X1463), mark(X2461))) :|: X1463 >= 0, z = 1 + (1 + X1463 + X2461), X2461 >= 0
   mark(z) -{ 2 }-> a__snd(a__snd(mark(X661))) :|: X661 >= 0, z = 1 + (1 + X661)
   mark(z) -{ 2 }-> a__snd(a__sel(mark(X1465), mark(X2463))) :|: z = 1 + (1 + X1465 + X2463), X1465 >= 0, X2463 >= 0
   mark(z) -{ 2 }-> a__snd(a__natsFrom(mark(X659))) :|: z = 1 + (1 + X659), X659 >= 0
   mark(z) -{ 2 }-> a__snd(a__head(mark(X662))) :|: z = 1 + (1 + X662), X662 >= 0
   mark(z) -{ 2 }-> a__snd(a__fst(mark(X660))) :|: X660 >= 0, z = 1 + (1 + X660)
   mark(z) -{ 2 }-> a__snd(a__afterNth(mark(X1466), mark(X2464))) :|: X1466 >= 0, X2464 >= 0, z = 1 + (1 + X1466 + X2464)
   mark(z) -{ 2 }-> a__snd(1) :|: z = 1 + 1
   mark(z) -{ 2 }-> a__snd(0) :|: z = 1 + 0
   mark(z) -{ 2 }-> a__snd(1 + mark(X664)) :|: X664 >= 0, z = 1 + (1 + X664)
   mark(z) -{ 2 }-> a__snd(1 + mark(X1468) + X2466) :|: X2466 >= 0, X1468 >= 0, z = 1 + (1 + X1468 + X2466)
   mark(z) -{ 2 }-> a__snd(1 + mark(X1469) + mark(X2467)) :|: X2467 >= 0, X1469 >= 0, z = 1 + (1 + X1469 + X2467)
   mark(z) -{ 1 }-> a__sel(mark(X1), mark(X2)) :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2
   mark(z) -{ 2 }-> a__natsFrom(a__u(mark(X1450), X2448, X3135, X4125)) :|: X1450 >= 0, z = 1 + (1 + X1450 + X2448 + X3135 + X4125), X3135 >= 0, X4125 >= 0, X2448 >= 0
   mark(z) -{ 2 }-> a__natsFrom(a__take(mark(X1453), mark(X2451))) :|: z = 1 + (1 + X1453 + X2451), X1453 >= 0, X2451 >= 0
   mark(z) -{ 2 }-> a__natsFrom(a__tail(mark(X651))) :|: X651 >= 0, z = 1 + (1 + X651)
   mark(z) -{ 2 }-> a__natsFrom(a__splitAt(mark(X1449), mark(X2447))) :|: X1449 >= 0, X2447 >= 0, z = 1 + (1 + X1449 + X2447)
   mark(z) -{ 2 }-> a__natsFrom(a__snd(mark(X649))) :|: X649 >= 0, z = 1 + (1 + X649)
   mark(z) -{ 2 }-> a__natsFrom(a__sel(mark(X1451), mark(X2449))) :|: X2449 >= 0, z = 1 + (1 + X1451 + X2449), X1451 >= 0
   mark(z) -{ 2 }-> a__natsFrom(a__natsFrom(mark(X647))) :|: X647 >= 0, z = 1 + (1 + X647)
   mark(z) -{ 2 }-> a__natsFrom(a__head(mark(X650))) :|: X650 >= 0, z = 1 + (1 + X650)
   mark(z) -{ 2 }-> a__natsFrom(a__fst(mark(X648))) :|: X648 >= 0, z = 1 + (1 + X648)
   mark(z) -{ 2 }-> a__natsFrom(a__afterNth(mark(X1452), mark(X2450))) :|: X1452 >= 0, X2450 >= 0, z = 1 + (1 + X1452 + X2450)
   mark(z) -{ 2 }-> a__natsFrom(1) :|: z = 1 + 1
   mark(z) -{ 2 }-> a__natsFrom(0) :|: z = 1 + 0
   mark(z) -{ 2 }-> a__natsFrom(1 + mark(X652)) :|: X652 >= 0, z = 1 + (1 + X652)
   mark(z) -{ 2 }-> a__natsFrom(1 + mark(X1454) + X2452) :|: X1454 >= 0, z = 1 + (1 + X1454 + X2452), X2452 >= 0
   mark(z) -{ 2 }-> a__natsFrom(1 + mark(X1455) + mark(X2453)) :|: z = 1 + (1 + X1455 + X2453), X1455 >= 0, X2453 >= 0
   mark(z) -{ 2 }-> a__head(a__u(mark(X1590), X2588, X3155, X4145)) :|: X1590 >= 0, X4145 >= 0, z = 1 + (1 + X1590 + X2588 + X3155 + X4145), X3155 >= 0, X2588 >= 0
   mark(z) -{ 2 }-> a__head(a__take(mark(X1593), mark(X2591))) :|: z = 1 + (1 + X1593 + X2591), X1593 >= 0, X2591 >= 0
   mark(z) -{ 2 }-> a__head(a__tail(mark(X771))) :|: z = 1 + (1 + X771), X771 >= 0
   mark(z) -{ 2 }-> a__head(a__splitAt(mark(X1589), mark(X2587))) :|: z = 1 + (1 + X1589 + X2587), X1589 >= 0, X2587 >= 0
   mark(z) -{ 2 }-> a__head(a__snd(mark(X769))) :|: z = 1 + (1 + X769), X769 >= 0
   mark(z) -{ 2 }-> a__head(a__sel(mark(X1591), mark(X2589))) :|: z = 1 + (1 + X1591 + X2589), X1591 >= 0, X2589 >= 0
   mark(z) -{ 2 }-> a__head(a__natsFrom(mark(X767))) :|: z = 1 + (1 + X767), X767 >= 0
   mark(z) -{ 2 }-> a__head(a__head(mark(X770))) :|: X770 >= 0, z = 1 + (1 + X770)
   mark(z) -{ 2 }-> a__head(a__fst(mark(X768))) :|: z = 1 + (1 + X768), X768 >= 0
   mark(z) -{ 2 }-> a__head(a__afterNth(mark(X1592), mark(X2590))) :|: z = 1 + (1 + X1592 + X2590), X1592 >= 0, X2590 >= 0
   mark(z) -{ 2 }-> a__head(1) :|: z = 1 + 1
   mark(z) -{ 2 }-> a__head(0) :|: z = 1 + 0
   mark(z) -{ 2 }-> a__head(1 + mark(X772)) :|: X772 >= 0, z = 1 + (1 + X772)
   mark(z) -{ 2 }-> a__head(1 + mark(X1594) + X2592) :|: X1594 >= 0, X2592 >= 0, z = 1 + (1 + X1594 + X2592)
   mark(z) -{ 2 }-> a__head(1 + mark(X1595) + mark(X2593)) :|: z = 1 + (1 + X1595 + X2593), X2593 >= 0, X1595 >= 0
   mark(z) -{ 2 }-> a__fst(a__u(mark(X1457), X2455, X3136, X4126)) :|: z = 1 + (1 + X1457 + X2455 + X3136 + X4126), X3136 >= 0, X4126 >= 0, X2455 >= 0, X1457 >= 0
   mark(z) -{ 2 }-> a__fst(a__take(mark(X1460), mark(X2458))) :|: X1460 >= 0, X2458 >= 0, z = 1 + (1 + X1460 + X2458)
   mark(z) -{ 2 }-> a__fst(a__tail(mark(X657))) :|: z = 1 + (1 + X657), X657 >= 0
   mark(z) -{ 2 }-> a__fst(a__splitAt(mark(X1456), mark(X2454))) :|: z = 1 + (1 + X1456 + X2454), X2454 >= 0, X1456 >= 0
   mark(z) -{ 2 }-> a__fst(a__snd(mark(X655))) :|: X655 >= 0, z = 1 + (1 + X655)
   mark(z) -{ 2 }-> a__fst(a__sel(mark(X1458), mark(X2456))) :|: X1458 >= 0, X2456 >= 0, z = 1 + (1 + X1458 + X2456)
   mark(z) -{ 2 }-> a__fst(a__natsFrom(mark(X653))) :|: z = 1 + (1 + X653), X653 >= 0
   mark(z) -{ 2 }-> a__fst(a__head(mark(X656))) :|: z = 1 + (1 + X656), X656 >= 0
   mark(z) -{ 2 }-> a__fst(a__fst(mark(X654))) :|: X654 >= 0, z = 1 + (1 + X654)
   mark(z) -{ 2 }-> a__fst(a__afterNth(mark(X1459), mark(X2457))) :|: z = 1 + (1 + X1459 + X2457), X1459 >= 0, X2457 >= 0
   mark(z) -{ 2 }-> a__fst(1) :|: z = 1 + 1
   mark(z) -{ 2 }-> a__fst(0) :|: z = 1 + 0
   mark(z) -{ 2 }-> a__fst(1 + mark(X658)) :|: X658 >= 0, z = 1 + (1 + X658)
   mark(z) -{ 2 }-> a__fst(1 + mark(X1461) + X2459) :|: X1461 >= 0, z = 1 + (1 + X1461 + X2459), X2459 >= 0
   mark(z) -{ 2 }-> a__fst(1 + mark(X1462) + mark(X2460)) :|: z = 1 + (1 + X1462 + X2460), X1462 >= 0, X2460 >= 0
   mark(z) -{ 1 }-> a__afterNth(mark(X1), mark(X2)) :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2
   mark(z) -{ 1 }-> 1 :|: z = 1
   mark(z) -{ 1 }-> 0 :|: z = 0
   mark(z) -{ 1 }-> 1 + mark(X) :|: z = 1 + X, X >= 0
   mark(z) -{ 1 }-> 1 + mark(X1) + X2 :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2
   mark(z) -{ 1 }-> 1 + mark(X1) + mark(X2) :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2


----------------------------------------

(29) SimplificationProof (BOTH BOUNDS(ID, ID))
Simplified the RNTS by moving equalities from the constraints into the right-hand sides.
----------------------------------------

(30)
Obligation:
Complexity RNTS consisting of the following rules:

   a__afterNth(z, z') -{ 1 }-> a__snd(a__splitAt(mark(z), mark(z'))) :|: z' >= 0, z >= 0
   a__afterNth(z, z') -{ 1 }-> 1 + z + z' :|: z >= 0, z' >= 0
   a__fst(z) -{ 1 }-> mark(XS) :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   a__fst(z) -{ 1 }-> 1 + z :|: z >= 0
   a__head(z) -{ 1 }-> mark(N) :|: z = 1 + N + XS, XS >= 0, N >= 0
   a__head(z) -{ 1 }-> 1 + z :|: z >= 0
   a__natsFrom(z) -{ 1 }-> 1 + z :|: z >= 0
   a__natsFrom(z) -{ 1 }-> 1 + mark(z) + (1 + (1 + z)) :|: z >= 0
   a__sel(z, z') -{ 1 }-> a__head(a__afterNth(mark(z), mark(z'))) :|: z' >= 0, z >= 0
   a__sel(z, z') -{ 1 }-> 1 + z + z' :|: z >= 0, z' >= 0
   a__snd(z) -{ 1 }-> mark(YS) :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   a__snd(z) -{ 1 }-> 1 + z :|: z >= 0
   a__splitAt(z, z') -{ 1 }-> a__u(a__splitAt(mark(z - 1), mark(XS)), z - 1, X, XS) :|: z' = 1 + X + XS, X >= 0, XS >= 0, z - 1 >= 0
   a__splitAt(z, z') -{ 1 }-> 1 + z + z' :|: z >= 0, z' >= 0
   a__splitAt(z, z') -{ 1 }-> 1 + 1 + mark(z') :|: z = 0, z' >= 0
   a__tail(z) -{ 1 }-> mark(XS) :|: z = 1 + N + XS, XS >= 0, N >= 0
   a__tail(z) -{ 1 }-> 1 + z :|: z >= 0
   a__take(z, z') -{ 1 }-> a__fst(a__splitAt(mark(z), mark(z'))) :|: z' >= 0, z >= 0
   a__take(z, z') -{ 1 }-> 1 + z + z' :|: z >= 0, z' >= 0
   a__u(z, z', z'', z1) -{ 1 }-> 1 + (1 + mark(z'') + YS) + mark(ZS) :|: z = 1 + YS + ZS, YS >= 0, z'' >= 0, ZS >= 0, z1 >= 0, z' >= 0
   a__u(z, z', z'', z1) -{ 1 }-> 1 + z + z' + z'' + z1 :|: z >= 0, z'' >= 0, z' >= 0, z1 >= 0
   mark(z) -{ 2 }-> a__u(a__u(mark(X1583), X2581, X3154, X4144), X2, X3, X4) :|: X4144 >= 0, X1583 >= 0, X3154 >= 0, X3 >= 0, z = 1 + (1 + X1583 + X2581 + X3154 + X4144) + X2 + X3 + X4, X2 >= 0, X4 >= 0, X2581 >= 0
   mark(z) -{ 2 }-> a__u(a__take(mark(X1586), mark(X2584)), X2, X3, X4) :|: z = 1 + (1 + X1586 + X2584) + X2 + X3 + X4, X2584 >= 0, X3 >= 0, X1586 >= 0, X2 >= 0, X4 >= 0
   mark(z) -{ 2 }-> a__u(a__tail(mark(X765)), X2, X3, X4) :|: X765 >= 0, X3 >= 0, z = 1 + (1 + X765) + X2 + X3 + X4, X2 >= 0, X4 >= 0
   mark(z) -{ 2 }-> a__u(a__splitAt(mark(X1582), mark(X2580)), X2, X3, X4) :|: z = 1 + (1 + X1582 + X2580) + X2 + X3 + X4, X3 >= 0, X1582 >= 0, X2 >= 0, X4 >= 0, X2580 >= 0
   mark(z) -{ 2 }-> a__u(a__snd(mark(X763)), X2, X3, X4) :|: X763 >= 0, X3 >= 0, X2 >= 0, X4 >= 0, z = 1 + (1 + X763) + X2 + X3 + X4
   mark(z) -{ 2 }-> a__u(a__sel(mark(X1584), mark(X2582)), X2, X3, X4) :|: z = 1 + (1 + X1584 + X2582) + X2 + X3 + X4, X1584 >= 0, X2582 >= 0, X3 >= 0, X2 >= 0, X4 >= 0
   mark(z) -{ 2 }-> a__u(a__natsFrom(mark(X761)), X2, X3, X4) :|: X3 >= 0, z = 1 + (1 + X761) + X2 + X3 + X4, X2 >= 0, X4 >= 0, X761 >= 0
   mark(z) -{ 2 }-> a__u(a__head(mark(X764)), X2, X3, X4) :|: z = 1 + (1 + X764) + X2 + X3 + X4, X764 >= 0, X3 >= 0, X2 >= 0, X4 >= 0
   mark(z) -{ 2 }-> a__u(a__fst(mark(X762)), X2, X3, X4) :|: z = 1 + (1 + X762) + X2 + X3 + X4, X3 >= 0, X2 >= 0, X4 >= 0, X762 >= 0
   mark(z) -{ 2 }-> a__u(a__afterNth(mark(X1585), mark(X2583)), X2, X3, X4) :|: X2583 >= 0, X3 >= 0, z = 1 + (1 + X1585 + X2583) + X2 + X3 + X4, X2 >= 0, X4 >= 0, X1585 >= 0
   mark(z) -{ 2 }-> a__u(1, X2, X3, X4) :|: X3 >= 0, X2 >= 0, X4 >= 0, z = 1 + 1 + X2 + X3 + X4
   mark(z) -{ 2 }-> a__u(0, X2, X3, X4) :|: X3 >= 0, z = 1 + 0 + X2 + X3 + X4, X2 >= 0, X4 >= 0
   mark(z) -{ 2 }-> a__u(1 + mark(X766), X2, X3, X4) :|: X766 >= 0, X3 >= 0, X2 >= 0, X4 >= 0, z = 1 + (1 + X766) + X2 + X3 + X4
   mark(z) -{ 2 }-> a__u(1 + mark(X1587) + X2585, X2, X3, X4) :|: X1587 >= 0, X2585 >= 0, X3 >= 0, z = 1 + (1 + X1587 + X2585) + X2 + X3 + X4, X2 >= 0, X4 >= 0
   mark(z) -{ 2 }-> a__u(1 + mark(X1588) + mark(X2586), X2, X3, X4) :|: X1588 >= 0, X2586 >= 0, X3 >= 0, z = 1 + (1 + X1588 + X2586) + X2 + X3 + X4, X2 >= 0, X4 >= 0
   mark(z) -{ 1 }-> a__take(mark(X1), mark(X2)) :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2
   mark(z) -{ 2 }-> a__tail(a__u(mark(X1597), X2595, X3156, X4146)) :|: z = 1 + (1 + X1597 + X2595 + X3156 + X4146), X3156 >= 0, X2595 >= 0, X4146 >= 0, X1597 >= 0
   mark(z) -{ 2 }-> a__tail(a__take(mark(X1600), mark(X2598))) :|: X1600 >= 0, z = 1 + (1 + X1600 + X2598), X2598 >= 0
   mark(z) -{ 2 }-> a__tail(a__tail(mark(z - 2))) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__tail(a__splitAt(mark(X1596), mark(X2594))) :|: X2594 >= 0, X1596 >= 0, z = 1 + (1 + X1596 + X2594)
   mark(z) -{ 2 }-> a__tail(a__snd(mark(z - 2))) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__tail(a__sel(mark(X1598), mark(X2596))) :|: z = 1 + (1 + X1598 + X2596), X1598 >= 0, X2596 >= 0
   mark(z) -{ 2 }-> a__tail(a__natsFrom(mark(z - 2))) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__tail(a__head(mark(z - 2))) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__tail(a__fst(mark(z - 2))) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__tail(a__afterNth(mark(X1599), mark(X2597))) :|: X1599 >= 0, z = 1 + (1 + X1599 + X2597), X2597 >= 0
   mark(z) -{ 2 }-> a__tail(1) :|: z = 1 + 1
   mark(z) -{ 2 }-> a__tail(0) :|: z = 1 + 0
   mark(z) -{ 2 }-> a__tail(1 + mark(z - 2)) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__tail(1 + mark(X1601) + X2599) :|: z = 1 + (1 + X1601 + X2599), X1601 >= 0, X2599 >= 0
   mark(z) -{ 2 }-> a__tail(1 + mark(X1602) + mark(X2600)) :|: X1602 >= 0, X2600 >= 0, z = 1 + (1 + X1602 + X2600)
   mark(z) -{ 1 }-> a__splitAt(mark(X1), mark(X2)) :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2
   mark(z) -{ 2 }-> a__snd(a__u(mark(X1464), X2462, X3137, X4127)) :|: X1464 >= 0, X2462 >= 0, z = 1 + (1 + X1464 + X2462 + X3137 + X4127), X4127 >= 0, X3137 >= 0
   mark(z) -{ 2 }-> a__snd(a__take(mark(X1467), mark(X2465))) :|: z = 1 + (1 + X1467 + X2465), X2465 >= 0, X1467 >= 0
   mark(z) -{ 2 }-> a__snd(a__tail(mark(z - 2))) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__snd(a__splitAt(mark(X1463), mark(X2461))) :|: X1463 >= 0, z = 1 + (1 + X1463 + X2461), X2461 >= 0
   mark(z) -{ 2 }-> a__snd(a__snd(mark(z - 2))) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__snd(a__sel(mark(X1465), mark(X2463))) :|: z = 1 + (1 + X1465 + X2463), X1465 >= 0, X2463 >= 0
   mark(z) -{ 2 }-> a__snd(a__natsFrom(mark(z - 2))) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__snd(a__head(mark(z - 2))) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__snd(a__fst(mark(z - 2))) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__snd(a__afterNth(mark(X1466), mark(X2464))) :|: X1466 >= 0, X2464 >= 0, z = 1 + (1 + X1466 + X2464)
   mark(z) -{ 2 }-> a__snd(1) :|: z = 1 + 1
   mark(z) -{ 2 }-> a__snd(0) :|: z = 1 + 0
   mark(z) -{ 2 }-> a__snd(1 + mark(z - 2)) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__snd(1 + mark(X1468) + X2466) :|: X2466 >= 0, X1468 >= 0, z = 1 + (1 + X1468 + X2466)
   mark(z) -{ 2 }-> a__snd(1 + mark(X1469) + mark(X2467)) :|: X2467 >= 0, X1469 >= 0, z = 1 + (1 + X1469 + X2467)
   mark(z) -{ 1 }-> a__sel(mark(X1), mark(X2)) :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2
   mark(z) -{ 2 }-> a__natsFrom(a__u(mark(X1450), X2448, X3135, X4125)) :|: X1450 >= 0, z = 1 + (1 + X1450 + X2448 + X3135 + X4125), X3135 >= 0, X4125 >= 0, X2448 >= 0
   mark(z) -{ 2 }-> a__natsFrom(a__take(mark(X1453), mark(X2451))) :|: z = 1 + (1 + X1453 + X2451), X1453 >= 0, X2451 >= 0
   mark(z) -{ 2 }-> a__natsFrom(a__tail(mark(z - 2))) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__natsFrom(a__splitAt(mark(X1449), mark(X2447))) :|: X1449 >= 0, X2447 >= 0, z = 1 + (1 + X1449 + X2447)
   mark(z) -{ 2 }-> a__natsFrom(a__snd(mark(z - 2))) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__natsFrom(a__sel(mark(X1451), mark(X2449))) :|: X2449 >= 0, z = 1 + (1 + X1451 + X2449), X1451 >= 0
   mark(z) -{ 2 }-> a__natsFrom(a__natsFrom(mark(z - 2))) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__natsFrom(a__head(mark(z - 2))) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__natsFrom(a__fst(mark(z - 2))) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__natsFrom(a__afterNth(mark(X1452), mark(X2450))) :|: X1452 >= 0, X2450 >= 0, z = 1 + (1 + X1452 + X2450)
   mark(z) -{ 2 }-> a__natsFrom(1) :|: z = 1 + 1
   mark(z) -{ 2 }-> a__natsFrom(0) :|: z = 1 + 0
   mark(z) -{ 2 }-> a__natsFrom(1 + mark(z - 2)) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__natsFrom(1 + mark(X1454) + X2452) :|: X1454 >= 0, z = 1 + (1 + X1454 + X2452), X2452 >= 0
   mark(z) -{ 2 }-> a__natsFrom(1 + mark(X1455) + mark(X2453)) :|: z = 1 + (1 + X1455 + X2453), X1455 >= 0, X2453 >= 0
   mark(z) -{ 2 }-> a__head(a__u(mark(X1590), X2588, X3155, X4145)) :|: X1590 >= 0, X4145 >= 0, z = 1 + (1 + X1590 + X2588 + X3155 + X4145), X3155 >= 0, X2588 >= 0
   mark(z) -{ 2 }-> a__head(a__take(mark(X1593), mark(X2591))) :|: z = 1 + (1 + X1593 + X2591), X1593 >= 0, X2591 >= 0
   mark(z) -{ 2 }-> a__head(a__tail(mark(z - 2))) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__head(a__splitAt(mark(X1589), mark(X2587))) :|: z = 1 + (1 + X1589 + X2587), X1589 >= 0, X2587 >= 0
   mark(z) -{ 2 }-> a__head(a__snd(mark(z - 2))) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__head(a__sel(mark(X1591), mark(X2589))) :|: z = 1 + (1 + X1591 + X2589), X1591 >= 0, X2589 >= 0
   mark(z) -{ 2 }-> a__head(a__natsFrom(mark(z - 2))) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__head(a__head(mark(z - 2))) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__head(a__fst(mark(z - 2))) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__head(a__afterNth(mark(X1592), mark(X2590))) :|: z = 1 + (1 + X1592 + X2590), X1592 >= 0, X2590 >= 0
   mark(z) -{ 2 }-> a__head(1) :|: z = 1 + 1
   mark(z) -{ 2 }-> a__head(0) :|: z = 1 + 0
   mark(z) -{ 2 }-> a__head(1 + mark(z - 2)) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__head(1 + mark(X1594) + X2592) :|: X1594 >= 0, X2592 >= 0, z = 1 + (1 + X1594 + X2592)
   mark(z) -{ 2 }-> a__head(1 + mark(X1595) + mark(X2593)) :|: z = 1 + (1 + X1595 + X2593), X2593 >= 0, X1595 >= 0
   mark(z) -{ 2 }-> a__fst(a__u(mark(X1457), X2455, X3136, X4126)) :|: z = 1 + (1 + X1457 + X2455 + X3136 + X4126), X3136 >= 0, X4126 >= 0, X2455 >= 0, X1457 >= 0
   mark(z) -{ 2 }-> a__fst(a__take(mark(X1460), mark(X2458))) :|: X1460 >= 0, X2458 >= 0, z = 1 + (1 + X1460 + X2458)
   mark(z) -{ 2 }-> a__fst(a__tail(mark(z - 2))) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__fst(a__splitAt(mark(X1456), mark(X2454))) :|: z = 1 + (1 + X1456 + X2454), X2454 >= 0, X1456 >= 0
   mark(z) -{ 2 }-> a__fst(a__snd(mark(z - 2))) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__fst(a__sel(mark(X1458), mark(X2456))) :|: X1458 >= 0, X2456 >= 0, z = 1 + (1 + X1458 + X2456)
   mark(z) -{ 2 }-> a__fst(a__natsFrom(mark(z - 2))) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__fst(a__head(mark(z - 2))) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__fst(a__fst(mark(z - 2))) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__fst(a__afterNth(mark(X1459), mark(X2457))) :|: z = 1 + (1 + X1459 + X2457), X1459 >= 0, X2457 >= 0
   mark(z) -{ 2 }-> a__fst(1) :|: z = 1 + 1
   mark(z) -{ 2 }-> a__fst(0) :|: z = 1 + 0
   mark(z) -{ 2 }-> a__fst(1 + mark(z - 2)) :|: z - 2 >= 0
   mark(z) -{ 2 }-> a__fst(1 + mark(X1461) + X2459) :|: X1461 >= 0, z = 1 + (1 + X1461 + X2459), X2459 >= 0
   mark(z) -{ 2 }-> a__fst(1 + mark(X1462) + mark(X2460)) :|: z = 1 + (1 + X1462 + X2460), X1462 >= 0, X2460 >= 0
   mark(z) -{ 1 }-> a__afterNth(mark(X1), mark(X2)) :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2
   mark(z) -{ 1 }-> 1 :|: z = 1
   mark(z) -{ 1 }-> 0 :|: z = 0
   mark(z) -{ 1 }-> 1 + mark(z - 1) :|: z - 1 >= 0
   mark(z) -{ 1 }-> 1 + mark(X1) + X2 :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2
   mark(z) -{ 1 }-> 1 + mark(X1) + mark(X2) :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2


----------------------------------------

(31) CompletionProof (UPPER BOUND(ID))
The TRS is a completely defined constructor system, as every type has a constant constructor and the following rules were added:
none

And the following fresh constants: none

----------------------------------------

(32)
Obligation:
Runtime Complexity Weighted TRS where all functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   a__natsFrom(N) -> cons(mark(N), natsFrom(s(N))) [1]
   a__fst(pair(XS, YS)) -> mark(XS) [1]
   a__snd(pair(XS, YS)) -> mark(YS) [1]
   a__splitAt(0, XS) -> pair(nil, mark(XS)) [1]
   a__splitAt(s(N), cons(X, XS)) -> a__u(a__splitAt(mark(N), mark(XS)), N, X, XS) [1]
   a__u(pair(YS, ZS), N, X, XS) -> pair(cons(mark(X), YS), mark(ZS)) [1]
   a__head(cons(N, XS)) -> mark(N) [1]
   a__tail(cons(N, XS)) -> mark(XS) [1]
   a__sel(N, XS) -> a__head(a__afterNth(mark(N), mark(XS))) [1]
   a__take(N, XS) -> a__fst(a__splitAt(mark(N), mark(XS))) [1]
   a__afterNth(N, XS) -> a__snd(a__splitAt(mark(N), mark(XS))) [1]
   mark(natsFrom(X)) -> a__natsFrom(mark(X)) [1]
   mark(fst(X)) -> a__fst(mark(X)) [1]
   mark(snd(X)) -> a__snd(mark(X)) [1]
   mark(splitAt(X1, X2)) -> a__splitAt(mark(X1), mark(X2)) [1]
   mark(u(X1, X2, X3, X4)) -> a__u(mark(X1), X2, X3, X4) [1]
   mark(head(X)) -> a__head(mark(X)) [1]
   mark(tail(X)) -> a__tail(mark(X)) [1]
   mark(sel(X1, X2)) -> a__sel(mark(X1), mark(X2)) [1]
   mark(afterNth(X1, X2)) -> a__afterNth(mark(X1), mark(X2)) [1]
   mark(take(X1, X2)) -> a__take(mark(X1), mark(X2)) [1]
   mark(cons(X1, X2)) -> cons(mark(X1), X2) [1]
   mark(s(X)) -> s(mark(X)) [1]
   mark(pair(X1, X2)) -> pair(mark(X1), mark(X2)) [1]
   mark(0) -> 0 [1]
   mark(nil) -> nil [1]
   a__natsFrom(X) -> natsFrom(X) [1]
   a__fst(X) -> fst(X) [1]
   a__snd(X) -> snd(X) [1]
   a__splitAt(X1, X2) -> splitAt(X1, X2) [1]
   a__u(X1, X2, X3, X4) -> u(X1, X2, X3, X4) [1]
   a__head(X) -> head(X) [1]
   a__tail(X) -> tail(X) [1]
   a__sel(X1, X2) -> sel(X1, X2) [1]
   a__afterNth(X1, X2) -> afterNth(X1, X2) [1]
   a__take(X1, X2) -> take(X1, X2) [1]

The TRS has the following type information:
a__natsFrom :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
cons :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
mark :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
natsFrom :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
s :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__fst :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
pair :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__snd :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__splitAt :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
0 :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
nil :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__u :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__head :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__tail :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__sel :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__afterNth :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
a__take :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
fst :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
snd :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
splitAt :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
u :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
head :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
tail :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
sel :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
afterNth :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take
take :: s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take -> s:natsFrom:cons:pair:0:nil:fst:snd:splitAt:u:head:tail:sel:afterNth:take

Rewrite Strategy: INNERMOST
----------------------------------------

(33) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID))
Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction.
The constant constructors are abstracted as follows:

   0 => 0
   nil => 1

----------------------------------------

(34)
Obligation:
Complexity RNTS consisting of the following rules:

   a__afterNth(z, z') -{ 1 }-> a__snd(a__splitAt(mark(N), mark(XS))) :|: z' = XS, z = N, XS >= 0, N >= 0
   a__afterNth(z, z') -{ 1 }-> 1 + X1 + X2 :|: X1 >= 0, X2 >= 0, z = X1, z' = X2
   a__fst(z) -{ 1 }-> mark(XS) :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   a__fst(z) -{ 1 }-> 1 + X :|: X >= 0, z = X
   a__head(z) -{ 1 }-> mark(N) :|: z = 1 + N + XS, XS >= 0, N >= 0
   a__head(z) -{ 1 }-> 1 + X :|: X >= 0, z = X
   a__natsFrom(z) -{ 1 }-> 1 + X :|: X >= 0, z = X
   a__natsFrom(z) -{ 1 }-> 1 + mark(N) + (1 + (1 + N)) :|: z = N, N >= 0
   a__sel(z, z') -{ 1 }-> a__head(a__afterNth(mark(N), mark(XS))) :|: z' = XS, z = N, XS >= 0, N >= 0
   a__sel(z, z') -{ 1 }-> 1 + X1 + X2 :|: X1 >= 0, X2 >= 0, z = X1, z' = X2
   a__snd(z) -{ 1 }-> mark(YS) :|: z = 1 + XS + YS, YS >= 0, XS >= 0
   a__snd(z) -{ 1 }-> 1 + X :|: X >= 0, z = X
   a__splitAt(z, z') -{ 1 }-> a__u(a__splitAt(mark(N), mark(XS)), N, X, XS) :|: z = 1 + N, z' = 1 + X + XS, X >= 0, XS >= 0, N >= 0
   a__splitAt(z, z') -{ 1 }-> 1 + X1 + X2 :|: X1 >= 0, X2 >= 0, z = X1, z' = X2
   a__splitAt(z, z') -{ 1 }-> 1 + 1 + mark(XS) :|: z' = XS, z = 0, XS >= 0
   a__tail(z) -{ 1 }-> mark(XS) :|: z = 1 + N + XS, XS >= 0, N >= 0
   a__tail(z) -{ 1 }-> 1 + X :|: X >= 0, z = X
   a__take(z, z') -{ 1 }-> a__fst(a__splitAt(mark(N), mark(XS))) :|: z' = XS, z = N, XS >= 0, N >= 0
   a__take(z, z') -{ 1 }-> 1 + X1 + X2 :|: X1 >= 0, X2 >= 0, z = X1, z' = X2
   a__u(z, z', z'', z1) -{ 1 }-> 1 + (1 + mark(X) + YS) + mark(ZS) :|: z = 1 + YS + ZS, z'' = X, YS >= 0, X >= 0, z' = N, z1 = XS, ZS >= 0, XS >= 0, N >= 0
   a__u(z, z', z'', z1) -{ 1 }-> 1 + X1 + X2 + X3 + X4 :|: X1 >= 0, z1 = X4, X3 >= 0, X2 >= 0, X4 >= 0, z = X1, z' = X2, z'' = X3
   mark(z) -{ 1 }-> a__u(mark(X1), X2, X3, X4) :|: X1 >= 0, z = 1 + X1 + X2 + X3 + X4, X3 >= 0, X2 >= 0, X4 >= 0
   mark(z) -{ 1 }-> a__take(mark(X1), mark(X2)) :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2
   mark(z) -{ 1 }-> a__tail(mark(X)) :|: z = 1 + X, X >= 0
   mark(z) -{ 1 }-> a__splitAt(mark(X1), mark(X2)) :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2
   mark(z) -{ 1 }-> a__snd(mark(X)) :|: z = 1 + X, X >= 0
   mark(z) -{ 1 }-> a__sel(mark(X1), mark(X2)) :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2
   mark(z) -{ 1 }-> a__natsFrom(mark(X)) :|: z = 1 + X, X >= 0
   mark(z) -{ 1 }-> a__head(mark(X)) :|: z = 1 + X, X >= 0
   mark(z) -{ 1 }-> a__fst(mark(X)) :|: z = 1 + X, X >= 0
   mark(z) -{ 1 }-> a__afterNth(mark(X1), mark(X2)) :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2
   mark(z) -{ 1 }-> 1 :|: z = 1
   mark(z) -{ 1 }-> 0 :|: z = 0
   mark(z) -{ 1 }-> 1 + mark(X) :|: z = 1 + X, X >= 0
   mark(z) -{ 1 }-> 1 + mark(X1) + X2 :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2
   mark(z) -{ 1 }-> 1 + mark(X1) + mark(X2) :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2

Only complete derivations are relevant for the runtime complexity.

----------------------------------------

(35) CpxTrsToCdtProof (UPPER BOUND(ID))
Converted Cpx (relative) TRS with rewrite strategy PARALLEL_INNERMOST to CDT
----------------------------------------

(36)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__NATSFROM(z0) -> c1
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__FST(z0) -> c3
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SND(z0) -> c5
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c7(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c8(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z2))
   A__SPLITAT(z0, z1) -> c9
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__U(z0, z1, z2, z3) -> c12
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__HEAD(z0) -> c14
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__TAIL(z0) -> c16
   A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   A__SEL(z0, z1) -> c19
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__TAKE(z0, z1) -> c22
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c25
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   MARK(0) -> c44
   MARK(nil) -> c45
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__NATSFROM(z0) -> c1
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__FST(z0) -> c3
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SND(z0) -> c5
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c7(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c8(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z2))
   A__SPLITAT(z0, z1) -> c9
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__U(z0, z1, z2, z3) -> c12
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__HEAD(z0) -> c14
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__TAIL(z0) -> c16
   A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   A__SEL(z0, z1) -> c19
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__TAKE(z0, z1) -> c22
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c25
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   MARK(0) -> c44
   MARK(nil) -> c45
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2, MARK_1

Compound Symbols:   c_1, c1, c2_1, c3, c4_1, c5, c6_1, c7_3, c8_3, c9, c10_1, c11_1, c12, c13_1, c14, c15_1, c16, c17_3, c18_3, c19, c20_3, c21_3, c22, c23_3, c24_3, c25, c26_2, c27_2, c28_2, c29_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c44, c45


----------------------------------------

(37) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 12 trailing nodes:
   A__TAKE(z0, z1) -> c22
   A__FST(z0) -> c3
   MARK(0) -> c44
   A__NATSFROM(z0) -> c1
   A__SEL(z0, z1) -> c19
   A__TAIL(z0) -> c16
   A__AFTERNTH(z0, z1) -> c25
   A__SND(z0) -> c5
   A__SPLITAT(z0, z1) -> c9
   A__U(z0, z1, z2, z3) -> c12
   MARK(nil) -> c45
   A__HEAD(z0) -> c14

----------------------------------------

(38)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c7(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c8(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z2))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c7(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c8(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z2))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2, MARK_1

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c7_3, c8_3, c10_1, c11_1, c13_1, c15_1, c17_3, c18_3, c20_3, c21_3, c23_3, c24_3, c26_2, c27_2, c28_2, c29_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1


----------------------------------------

(39) CdtToCpxRelTrsProof (BOTH BOUNDS(ID, ID))
Converted S to standard rules, and D \ S as well as R to relative rules.
----------------------------------------

(40)
Obligation:
The Runtime Complexity (innermost) of the given CpxRelTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c7(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c8(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z2))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))

The (relative) TRS S consists of the following rules:

   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil

Rewrite Strategy: INNERMOST
----------------------------------------

(41) RelTrsToTrsProof (UPPER BOUND(ID))
transformed relative TRS to TRS
----------------------------------------

(42)
Obligation:
The Runtime Complexity (innermost) of the given CpxTRS could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c7(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c8(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z2))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil

S is empty.
Rewrite Strategy: INNERMOST
----------------------------------------

(43) RelTrsToWeightedTrsProof (BOTH BOUNDS(ID, ID))
Transformed relative TRS to weighted TRS
----------------------------------------

(44)
Obligation:
The Runtime Complexity (innermost) of the given CpxWeightedTrs could be proven to be BOUNDS(1, INF).


The TRS R consists of the following rules:

   A__NATSFROM(z0) -> c(MARK(z0)) [1]
   A__FST(pair(z0, z1)) -> c2(MARK(z0)) [1]
   A__SND(pair(z0, z1)) -> c4(MARK(z1)) [1]
   A__SPLITAT(0, z0) -> c6(MARK(z0)) [1]
   A__SPLITAT(s(z0), cons(z1, z2)) -> c7(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z0)) [1]
   A__SPLITAT(s(z0), cons(z1, z2)) -> c8(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z2)) [1]
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3)) [1]
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1)) [1]
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0)) [1]
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1)) [1]
   A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0)) [1]
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1)) [1]
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0)) [1]
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1)) [1]
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0)) [1]
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1)) [1]
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0)) [1]
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0)) [1]
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0)) [1]
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0)) [1]
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1)) [1]
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0)) [1]
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0)) [1]
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0)) [1]
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0)) [1]
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1)) [1]
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0)) [1]
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1)) [1]
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0)) [1]
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1)) [1]
   MARK(cons(z0, z1)) -> c40(MARK(z0)) [1]
   MARK(s(z0)) -> c41(MARK(z0)) [1]
   MARK(pair(z0, z1)) -> c42(MARK(z0)) [1]
   MARK(pair(z0, z1)) -> c43(MARK(z1)) [1]
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0))) [0]
   a__natsFrom(z0) -> natsFrom(z0) [0]
   a__fst(pair(z0, z1)) -> mark(z0) [0]
   a__fst(z0) -> fst(z0) [0]
   a__snd(pair(z0, z1)) -> mark(z1) [0]
   a__snd(z0) -> snd(z0) [0]
   a__splitAt(0, z0) -> pair(nil, mark(z0)) [0]
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2) [0]
   a__splitAt(z0, z1) -> splitAt(z0, z1) [0]
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1)) [0]
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3) [0]
   a__head(cons(z0, z1)) -> mark(z0) [0]
   a__head(z0) -> head(z0) [0]
   a__tail(cons(z0, z1)) -> mark(z1) [0]
   a__tail(z0) -> tail(z0) [0]
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1))) [0]
   a__sel(z0, z1) -> sel(z0, z1) [0]
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1))) [0]
   a__take(z0, z1) -> take(z0, z1) [0]
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1))) [0]
   a__afterNth(z0, z1) -> afterNth(z0, z1) [0]
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0)) [0]
   mark(fst(z0)) -> a__fst(mark(z0)) [0]
   mark(snd(z0)) -> a__snd(mark(z0)) [0]
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1)) [0]
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3) [0]
   mark(head(z0)) -> a__head(mark(z0)) [0]
   mark(tail(z0)) -> a__tail(mark(z0)) [0]
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1)) [0]
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1)) [0]
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1)) [0]
   mark(cons(z0, z1)) -> cons(mark(z0), z1) [0]
   mark(s(z0)) -> s(mark(z0)) [0]
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1)) [0]
   mark(0) -> 0 [0]
   mark(nil) -> nil [0]

Rewrite Strategy: INNERMOST
----------------------------------------

(45) TypeInferenceProof (BOTH BOUNDS(ID, ID))
Infered types.
----------------------------------------

(46)
Obligation:
Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   A__NATSFROM(z0) -> c(MARK(z0)) [1]
   A__FST(pair(z0, z1)) -> c2(MARK(z0)) [1]
   A__SND(pair(z0, z1)) -> c4(MARK(z1)) [1]
   A__SPLITAT(0, z0) -> c6(MARK(z0)) [1]
   A__SPLITAT(s(z0), cons(z1, z2)) -> c7(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z0)) [1]
   A__SPLITAT(s(z0), cons(z1, z2)) -> c8(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z2)) [1]
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3)) [1]
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1)) [1]
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0)) [1]
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1)) [1]
   A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0)) [1]
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1)) [1]
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0)) [1]
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1)) [1]
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0)) [1]
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1)) [1]
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0)) [1]
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0)) [1]
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0)) [1]
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0)) [1]
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1)) [1]
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0)) [1]
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0)) [1]
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0)) [1]
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0)) [1]
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1)) [1]
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0)) [1]
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1)) [1]
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0)) [1]
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1)) [1]
   MARK(cons(z0, z1)) -> c40(MARK(z0)) [1]
   MARK(s(z0)) -> c41(MARK(z0)) [1]
   MARK(pair(z0, z1)) -> c42(MARK(z0)) [1]
   MARK(pair(z0, z1)) -> c43(MARK(z1)) [1]
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0))) [0]
   a__natsFrom(z0) -> natsFrom(z0) [0]
   a__fst(pair(z0, z1)) -> mark(z0) [0]
   a__fst(z0) -> fst(z0) [0]
   a__snd(pair(z0, z1)) -> mark(z1) [0]
   a__snd(z0) -> snd(z0) [0]
   a__splitAt(0, z0) -> pair(nil, mark(z0)) [0]
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2) [0]
   a__splitAt(z0, z1) -> splitAt(z0, z1) [0]
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1)) [0]
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3) [0]
   a__head(cons(z0, z1)) -> mark(z0) [0]
   a__head(z0) -> head(z0) [0]
   a__tail(cons(z0, z1)) -> mark(z1) [0]
   a__tail(z0) -> tail(z0) [0]
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1))) [0]
   a__sel(z0, z1) -> sel(z0, z1) [0]
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1))) [0]
   a__take(z0, z1) -> take(z0, z1) [0]
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1))) [0]
   a__afterNth(z0, z1) -> afterNth(z0, z1) [0]
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0)) [0]
   mark(fst(z0)) -> a__fst(mark(z0)) [0]
   mark(snd(z0)) -> a__snd(mark(z0)) [0]
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1)) [0]
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3) [0]
   mark(head(z0)) -> a__head(mark(z0)) [0]
   mark(tail(z0)) -> a__tail(mark(z0)) [0]
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1)) [0]
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1)) [0]
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1)) [0]
   mark(cons(z0, z1)) -> cons(mark(z0), z1) [0]
   mark(s(z0)) -> s(mark(z0)) [0]
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1)) [0]
   mark(0) -> 0 [0]
   mark(nil) -> nil [0]

The TRS has the following type information:
A__NATSFROM :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c
c :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c
MARK :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
A__FST :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c2
pair :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c2 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c2
A__SND :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c4
c4 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c4
A__SPLITAT :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c6:c7:c8
0 :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c6 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c6:c7:c8
s :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
cons :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c7 :: c10:c11 -> c6:c7:c8 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c6:c7:c8
A__U :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c10:c11
a__splitAt :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
mark :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c8 :: c10:c11 -> c6:c7:c8 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c6:c7:c8
c10 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c10:c11
c11 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c10:c11
A__HEAD :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c13
c13 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c13
A__TAIL :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c15
c15 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c15
A__SEL :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c17:c18
c17 :: c13 -> c23:c24 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c17:c18
a__afterNth :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
A__AFTERNTH :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c23:c24
c18 :: c13 -> c23:c24 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c17:c18
A__TAKE :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> c20:c21
c20 :: c2 -> c6:c7:c8 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c20:c21
c21 :: c2 -> c6:c7:c8 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c20:c21
c23 :: c4 -> c6:c7:c8 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c23:c24
c24 :: c4 -> c6:c7:c8 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c23:c24
natsFrom :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c26 :: c -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
fst :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c27 :: c2 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
snd :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c28 :: c4 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
splitAt :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c29 :: c6:c7:c8 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
c30 :: c6:c7:c8 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
u :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c31 :: c10:c11 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
head :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c32 :: c13 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
tail :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c33 :: c15 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
sel :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c34 :: c17:c18 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
c35 :: c17:c18 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
afterNth :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c36 :: c23:c24 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
c37 :: c23:c24 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
take :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
c38 :: c20:c21 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
c39 :: c20:c21 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
c40 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
c41 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
c42 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
c43 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
a__natsFrom :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__fst :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__snd :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
nil :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__u :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__head :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__tail :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__sel :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil
a__take :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil

Rewrite Strategy: INNERMOST
----------------------------------------

(47) CompletionProof (UPPER BOUND(ID))
The transformation into a RNTS is sound, since:

(a) The obligation is a constructor system where every type has a constant constructor,

(b) The following defined symbols do not have to be completely defined, as they can never occur inside other defined symbols:

   A__NATSFROM_1
   A__FST_1
   A__SND_1
   A__SPLITAT_2
   A__U_4
   A__HEAD_1
   A__TAIL_1
   A__SEL_2
   A__TAKE_2
   A__AFTERNTH_2
   MARK_1

(c) The following functions are completely defined:

   a__natsFrom_1
   a__fst_1
   a__snd_1
   a__splitAt_2
   a__u_4
   a__head_1
   a__tail_1
   a__sel_2
   a__take_2
   a__afterNth_2
   mark_1

Due to the following rules being added:

   a__natsFrom(v0) -> null_a__natsFrom [0]
   a__fst(v0) -> null_a__fst [0]
   a__snd(v0) -> null_a__snd [0]
   a__splitAt(v0, v1) -> null_a__splitAt [0]
   a__u(v0, v1, v2, v3) -> null_a__u [0]
   a__head(v0) -> null_a__head [0]
   a__tail(v0) -> null_a__tail [0]
   a__sel(v0, v1) -> null_a__sel [0]
   a__take(v0, v1) -> null_a__take [0]
   a__afterNth(v0, v1) -> null_a__afterNth [0]
   mark(v0) -> null_mark [0]

And the following fresh constants:    null_a__natsFrom, null_a__fst, null_a__snd, null_a__splitAt, null_a__u, null_a__head, null_a__tail, null_a__sel, null_a__take, null_a__afterNth, null_mark, const, const1, const2, const3, const4, const5, const6, const7, const8, const9, const10

----------------------------------------

(48)
Obligation:
Runtime Complexity Weighted TRS where critical functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   A__NATSFROM(z0) -> c(MARK(z0)) [1]
   A__FST(pair(z0, z1)) -> c2(MARK(z0)) [1]
   A__SND(pair(z0, z1)) -> c4(MARK(z1)) [1]
   A__SPLITAT(0, z0) -> c6(MARK(z0)) [1]
   A__SPLITAT(s(z0), cons(z1, z2)) -> c7(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z0)) [1]
   A__SPLITAT(s(z0), cons(z1, z2)) -> c8(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z2)) [1]
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3)) [1]
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1)) [1]
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0)) [1]
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1)) [1]
   A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0)) [1]
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1)) [1]
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0)) [1]
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1)) [1]
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0)) [1]
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1)) [1]
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0)) [1]
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0)) [1]
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0)) [1]
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0)) [1]
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1)) [1]
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0)) [1]
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0)) [1]
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0)) [1]
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0)) [1]
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1)) [1]
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0)) [1]
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1)) [1]
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0)) [1]
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1)) [1]
   MARK(cons(z0, z1)) -> c40(MARK(z0)) [1]
   MARK(s(z0)) -> c41(MARK(z0)) [1]
   MARK(pair(z0, z1)) -> c42(MARK(z0)) [1]
   MARK(pair(z0, z1)) -> c43(MARK(z1)) [1]
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0))) [0]
   a__natsFrom(z0) -> natsFrom(z0) [0]
   a__fst(pair(z0, z1)) -> mark(z0) [0]
   a__fst(z0) -> fst(z0) [0]
   a__snd(pair(z0, z1)) -> mark(z1) [0]
   a__snd(z0) -> snd(z0) [0]
   a__splitAt(0, z0) -> pair(nil, mark(z0)) [0]
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2) [0]
   a__splitAt(z0, z1) -> splitAt(z0, z1) [0]
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1)) [0]
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3) [0]
   a__head(cons(z0, z1)) -> mark(z0) [0]
   a__head(z0) -> head(z0) [0]
   a__tail(cons(z0, z1)) -> mark(z1) [0]
   a__tail(z0) -> tail(z0) [0]
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1))) [0]
   a__sel(z0, z1) -> sel(z0, z1) [0]
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1))) [0]
   a__take(z0, z1) -> take(z0, z1) [0]
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1))) [0]
   a__afterNth(z0, z1) -> afterNth(z0, z1) [0]
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0)) [0]
   mark(fst(z0)) -> a__fst(mark(z0)) [0]
   mark(snd(z0)) -> a__snd(mark(z0)) [0]
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1)) [0]
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3) [0]
   mark(head(z0)) -> a__head(mark(z0)) [0]
   mark(tail(z0)) -> a__tail(mark(z0)) [0]
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1)) [0]
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1)) [0]
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1)) [0]
   mark(cons(z0, z1)) -> cons(mark(z0), z1) [0]
   mark(s(z0)) -> s(mark(z0)) [0]
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1)) [0]
   mark(0) -> 0 [0]
   mark(nil) -> nil [0]
   a__natsFrom(v0) -> null_a__natsFrom [0]
   a__fst(v0) -> null_a__fst [0]
   a__snd(v0) -> null_a__snd [0]
   a__splitAt(v0, v1) -> null_a__splitAt [0]
   a__u(v0, v1, v2, v3) -> null_a__u [0]
   a__head(v0) -> null_a__head [0]
   a__tail(v0) -> null_a__tail [0]
   a__sel(v0, v1) -> null_a__sel [0]
   a__take(v0, v1) -> null_a__take [0]
   a__afterNth(v0, v1) -> null_a__afterNth [0]
   mark(v0) -> null_mark [0]

The TRS has the following type information:
A__NATSFROM :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> c
c :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c
MARK :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
A__FST :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> c2
pair :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c2 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c2
A__SND :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> c4
c4 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c4
A__SPLITAT :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> c6:c7:c8
0 :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c6 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c6:c7:c8
s :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
cons :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c7 :: c10:c11 -> c6:c7:c8 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c6:c7:c8
A__U :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> c10:c11
a__splitAt :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
mark :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c8 :: c10:c11 -> c6:c7:c8 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c6:c7:c8
c10 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c10:c11
c11 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c10:c11
A__HEAD :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> c13
c13 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c13
A__TAIL :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> c15
c15 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c15
A__SEL :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> c17:c18
c17 :: c13 -> c23:c24 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c17:c18
a__afterNth :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
A__AFTERNTH :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> c23:c24
c18 :: c13 -> c23:c24 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c17:c18
A__TAKE :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> c20:c21
c20 :: c2 -> c6:c7:c8 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c20:c21
c21 :: c2 -> c6:c7:c8 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c20:c21
c23 :: c4 -> c6:c7:c8 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c23:c24
c24 :: c4 -> c6:c7:c8 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c23:c24
natsFrom :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c26 :: c -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
fst :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c27 :: c2 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
snd :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c28 :: c4 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
splitAt :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c29 :: c6:c7:c8 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
c30 :: c6:c7:c8 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
u :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c31 :: c10:c11 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
head :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c32 :: c13 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
tail :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c33 :: c15 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
sel :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c34 :: c17:c18 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
c35 :: c17:c18 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
afterNth :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c36 :: c23:c24 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
c37 :: c23:c24 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
take :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c38 :: c20:c21 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
c39 :: c20:c21 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
c40 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
c41 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
c42 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
c43 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
a__natsFrom :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
a__fst :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
a__snd :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
nil :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
a__u :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
a__head :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
a__tail :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
a__sel :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
a__take :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
null_a__natsFrom :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
null_a__fst :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
null_a__snd :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
null_a__splitAt :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
null_a__u :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
null_a__head :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
null_a__tail :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
null_a__sel :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
null_a__take :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
null_a__afterNth :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
null_mark :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
const :: c
const1 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43
const2 :: c2
const3 :: c4
const4 :: c6:c7:c8
const5 :: c10:c11
const6 :: c13
const7 :: c15
const8 :: c17:c18
const9 :: c23:c24
const10 :: c20:c21

Rewrite Strategy: INNERMOST
----------------------------------------

(49) CompletionProof (UPPER BOUND(ID))
The TRS is a completely defined constructor system, as every type has a constant constructor and the following rules were added:

   a__natsFrom(v0) -> null_a__natsFrom [0]
   a__fst(v0) -> null_a__fst [0]
   a__snd(v0) -> null_a__snd [0]
   a__splitAt(v0, v1) -> null_a__splitAt [0]
   a__u(v0, v1, v2, v3) -> null_a__u [0]
   a__head(v0) -> null_a__head [0]
   a__tail(v0) -> null_a__tail [0]
   a__sel(v0, v1) -> null_a__sel [0]
   a__take(v0, v1) -> null_a__take [0]
   a__afterNth(v0, v1) -> null_a__afterNth [0]
   mark(v0) -> null_mark [0]
   A__FST(v0) -> null_A__FST [0]
   A__SND(v0) -> null_A__SND [0]
   A__SPLITAT(v0, v1) -> null_A__SPLITAT [0]
   A__U(v0, v1, v2, v3) -> null_A__U [0]
   A__HEAD(v0) -> null_A__HEAD [0]
   A__TAIL(v0) -> null_A__TAIL [0]
   MARK(v0) -> null_MARK [0]

And the following fresh constants:    null_a__natsFrom, null_a__fst, null_a__snd, null_a__splitAt, null_a__u, null_a__head, null_a__tail, null_a__sel, null_a__take, null_a__afterNth, null_mark, null_A__FST, null_A__SND, null_A__SPLITAT, null_A__U, null_A__HEAD, null_A__TAIL, null_MARK, const, const1, const2, const3

----------------------------------------

(50)
Obligation:
Runtime Complexity Weighted TRS where all functions are completely defined. The underlying TRS is:

Runtime Complexity Weighted TRS with Types.
The TRS R consists of the following rules:

   A__NATSFROM(z0) -> c(MARK(z0)) [1]
   A__FST(pair(z0, z1)) -> c2(MARK(z0)) [1]
   A__SND(pair(z0, z1)) -> c4(MARK(z1)) [1]
   A__SPLITAT(0, z0) -> c6(MARK(z0)) [1]
   A__SPLITAT(s(z0), cons(z1, z2)) -> c7(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z0)) [1]
   A__SPLITAT(s(z0), cons(z1, z2)) -> c8(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z2)) [1]
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3)) [1]
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1)) [1]
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0)) [1]
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1)) [1]
   A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0)) [1]
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1)) [1]
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0)) [1]
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1)) [1]
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0)) [1]
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1)) [1]
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0)) [1]
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0)) [1]
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0)) [1]
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0)) [1]
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1)) [1]
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0)) [1]
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0)) [1]
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0)) [1]
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0)) [1]
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1)) [1]
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0)) [1]
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1)) [1]
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0)) [1]
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1)) [1]
   MARK(cons(z0, z1)) -> c40(MARK(z0)) [1]
   MARK(s(z0)) -> c41(MARK(z0)) [1]
   MARK(pair(z0, z1)) -> c42(MARK(z0)) [1]
   MARK(pair(z0, z1)) -> c43(MARK(z1)) [1]
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0))) [0]
   a__natsFrom(z0) -> natsFrom(z0) [0]
   a__fst(pair(z0, z1)) -> mark(z0) [0]
   a__fst(z0) -> fst(z0) [0]
   a__snd(pair(z0, z1)) -> mark(z1) [0]
   a__snd(z0) -> snd(z0) [0]
   a__splitAt(0, z0) -> pair(nil, mark(z0)) [0]
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2) [0]
   a__splitAt(z0, z1) -> splitAt(z0, z1) [0]
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1)) [0]
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3) [0]
   a__head(cons(z0, z1)) -> mark(z0) [0]
   a__head(z0) -> head(z0) [0]
   a__tail(cons(z0, z1)) -> mark(z1) [0]
   a__tail(z0) -> tail(z0) [0]
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1))) [0]
   a__sel(z0, z1) -> sel(z0, z1) [0]
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1))) [0]
   a__take(z0, z1) -> take(z0, z1) [0]
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1))) [0]
   a__afterNth(z0, z1) -> afterNth(z0, z1) [0]
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0)) [0]
   mark(fst(z0)) -> a__fst(mark(z0)) [0]
   mark(snd(z0)) -> a__snd(mark(z0)) [0]
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1)) [0]
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3) [0]
   mark(head(z0)) -> a__head(mark(z0)) [0]
   mark(tail(z0)) -> a__tail(mark(z0)) [0]
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1)) [0]
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1)) [0]
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1)) [0]
   mark(cons(z0, z1)) -> cons(mark(z0), z1) [0]
   mark(s(z0)) -> s(mark(z0)) [0]
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1)) [0]
   mark(0) -> 0 [0]
   mark(nil) -> nil [0]
   a__natsFrom(v0) -> null_a__natsFrom [0]
   a__fst(v0) -> null_a__fst [0]
   a__snd(v0) -> null_a__snd [0]
   a__splitAt(v0, v1) -> null_a__splitAt [0]
   a__u(v0, v1, v2, v3) -> null_a__u [0]
   a__head(v0) -> null_a__head [0]
   a__tail(v0) -> null_a__tail [0]
   a__sel(v0, v1) -> null_a__sel [0]
   a__take(v0, v1) -> null_a__take [0]
   a__afterNth(v0, v1) -> null_a__afterNth [0]
   mark(v0) -> null_mark [0]
   A__FST(v0) -> null_A__FST [0]
   A__SND(v0) -> null_A__SND [0]
   A__SPLITAT(v0, v1) -> null_A__SPLITAT [0]
   A__U(v0, v1, v2, v3) -> null_A__U [0]
   A__HEAD(v0) -> null_A__HEAD [0]
   A__TAIL(v0) -> null_A__TAIL [0]
   MARK(v0) -> null_MARK [0]

The TRS has the following type information:
A__NATSFROM :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> c
c :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c
MARK :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK
A__FST :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> c2:null_A__FST
pair :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c2 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c2:null_A__FST
A__SND :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> c4:null_A__SND
c4 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c4:null_A__SND
A__SPLITAT :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> c6:c7:c8:null_A__SPLITAT
0 :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c6 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c6:c7:c8:null_A__SPLITAT
s :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
cons :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c7 :: c10:c11:null_A__U -> c6:c7:c8:null_A__SPLITAT -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c6:c7:c8:null_A__SPLITAT
A__U :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> c10:c11:null_A__U
a__splitAt :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
mark :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c8 :: c10:c11:null_A__U -> c6:c7:c8:null_A__SPLITAT -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c6:c7:c8:null_A__SPLITAT
c10 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c10:c11:null_A__U
c11 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c10:c11:null_A__U
A__HEAD :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> c13:null_A__HEAD
c13 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c13:null_A__HEAD
A__TAIL :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> c15:null_A__TAIL
c15 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c15:null_A__TAIL
A__SEL :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> c17:c18
c17 :: c13:null_A__HEAD -> c23:c24 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c17:c18
a__afterNth :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
A__AFTERNTH :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> c23:c24
c18 :: c13:null_A__HEAD -> c23:c24 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c17:c18
A__TAKE :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> c20:c21
c20 :: c2:null_A__FST -> c6:c7:c8:null_A__SPLITAT -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c20:c21
c21 :: c2:null_A__FST -> c6:c7:c8:null_A__SPLITAT -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c20:c21
c23 :: c4:null_A__SND -> c6:c7:c8:null_A__SPLITAT -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c23:c24
c24 :: c4:null_A__SND -> c6:c7:c8:null_A__SPLITAT -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c23:c24
natsFrom :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c26 :: c -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK
fst :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c27 :: c2:null_A__FST -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK
snd :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c28 :: c4:null_A__SND -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK
splitAt :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c29 :: c6:c7:c8:null_A__SPLITAT -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK
c30 :: c6:c7:c8:null_A__SPLITAT -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK
u :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c31 :: c10:c11:null_A__U -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK
head :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c32 :: c13:null_A__HEAD -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK
tail :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c33 :: c15:null_A__TAIL -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK
sel :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c34 :: c17:c18 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK
c35 :: c17:c18 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK
afterNth :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c36 :: c23:c24 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK
c37 :: c23:c24 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK
take :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
c38 :: c20:c21 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK
c39 :: c20:c21 -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK
c40 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK
c41 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK
c42 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK
c43 :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK -> c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK
a__natsFrom :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
a__fst :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
a__snd :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
nil :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
a__u :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
a__head :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
a__tail :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
a__sel :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
a__take :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark -> pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
null_a__natsFrom :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
null_a__fst :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
null_a__snd :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
null_a__splitAt :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
null_a__u :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
null_a__head :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
null_a__tail :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
null_a__sel :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
null_a__take :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
null_a__afterNth :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
null_mark :: pair:0:s:cons:natsFrom:fst:snd:splitAt:u:head:tail:sel:afterNth:take:nil:null_a__natsFrom:null_a__fst:null_a__snd:null_a__splitAt:null_a__u:null_a__head:null_a__tail:null_a__sel:null_a__take:null_a__afterNth:null_mark
null_A__FST :: c2:null_A__FST
null_A__SND :: c4:null_A__SND
null_A__SPLITAT :: c6:c7:c8:null_A__SPLITAT
null_A__U :: c10:c11:null_A__U
null_A__HEAD :: c13:null_A__HEAD
null_A__TAIL :: c15:null_A__TAIL
null_MARK :: c26:c27:c28:c29:c30:c31:c32:c33:c34:c35:c36:c37:c38:c39:c40:c41:c42:c43:null_MARK
const :: c
const1 :: c17:c18
const2 :: c23:c24
const3 :: c20:c21

Rewrite Strategy: INNERMOST
----------------------------------------

(51) CpxTypedWeightedTrsToRntsProof (UPPER BOUND(ID))
Transformed the TRS into an over-approximating RNTS by (improved) Size Abstraction.
The constant constructors are abstracted as follows:

   0 => 0
   nil => 1
   null_a__natsFrom => 0
   null_a__fst => 0
   null_a__snd => 0
   null_a__splitAt => 0
   null_a__u => 0
   null_a__head => 0
   null_a__tail => 0
   null_a__sel => 0
   null_a__take => 0
   null_a__afterNth => 0
   null_mark => 0
   null_A__FST => 0
   null_A__SND => 0
   null_A__SPLITAT => 0
   null_A__U => 0
   null_A__HEAD => 0
   null_A__TAIL => 0
   null_MARK => 0
   const => 0
   const1 => 0
   const2 => 0
   const3 => 0

----------------------------------------

(52)
Obligation:
Complexity RNTS consisting of the following rules:

   A__AFTERNTH(z, z') -{ 1 }-> 1 + A__SND(a__splitAt(mark(z0), mark(z1))) + A__SPLITAT(mark(z0), mark(z1)) + MARK(z0) :|: z = z0, z1 >= 0, z' = z1, z0 >= 0
   A__AFTERNTH(z, z') -{ 1 }-> 1 + A__SND(a__splitAt(mark(z0), mark(z1))) + A__SPLITAT(mark(z0), mark(z1)) + MARK(z1) :|: z = z0, z1 >= 0, z' = z1, z0 >= 0
   A__FST(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   A__FST(z) -{ 1 }-> 1 + MARK(z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   A__HEAD(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   A__HEAD(z) -{ 1 }-> 1 + MARK(z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   A__NATSFROM(z) -{ 1 }-> 1 + MARK(z0) :|: z = z0, z0 >= 0
   A__SEL(z, z') -{ 1 }-> 1 + A__HEAD(a__afterNth(mark(z0), mark(z1))) + A__AFTERNTH(mark(z0), mark(z1)) + MARK(z0) :|: z = z0, z1 >= 0, z' = z1, z0 >= 0
   A__SEL(z, z') -{ 1 }-> 1 + A__HEAD(a__afterNth(mark(z0), mark(z1))) + A__AFTERNTH(mark(z0), mark(z1)) + MARK(z1) :|: z = z0, z1 >= 0, z' = z1, z0 >= 0
   A__SND(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   A__SND(z) -{ 1 }-> 1 + MARK(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   A__SPLITAT(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   A__SPLITAT(z, z') -{ 1 }-> 1 + MARK(z0) :|: z0 >= 0, z = 0, z' = z0
   A__SPLITAT(z, z') -{ 1 }-> 1 + A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2) + A__SPLITAT(mark(z0), mark(z2)) + MARK(z0) :|: z1 >= 0, z' = 1 + z1 + z2, z = 1 + z0, z0 >= 0, z2 >= 0
   A__SPLITAT(z, z') -{ 1 }-> 1 + A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2) + A__SPLITAT(mark(z0), mark(z2)) + MARK(z2) :|: z1 >= 0, z' = 1 + z1 + z2, z = 1 + z0, z0 >= 0, z2 >= 0
   A__TAIL(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   A__TAIL(z) -{ 1 }-> 1 + MARK(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   A__TAKE(z, z') -{ 1 }-> 1 + A__FST(a__splitAt(mark(z0), mark(z1))) + A__SPLITAT(mark(z0), mark(z1)) + MARK(z0) :|: z = z0, z1 >= 0, z' = z1, z0 >= 0
   A__TAKE(z, z') -{ 1 }-> 1 + A__FST(a__splitAt(mark(z0), mark(z1))) + A__SPLITAT(mark(z0), mark(z1)) + MARK(z1) :|: z = z0, z1 >= 0, z' = z1, z0 >= 0
   A__U(z, z', z'', z5) -{ 0 }-> 0 :|: z5 = v3, v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0, v3 >= 0
   A__U(z, z', z'', z5) -{ 1 }-> 1 + MARK(z1) :|: z1 >= 0, z5 = z4, z' = z2, z0 >= 0, z'' = z3, z4 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   A__U(z, z', z'', z5) -{ 1 }-> 1 + MARK(z3) :|: z1 >= 0, z5 = z4, z' = z2, z0 >= 0, z'' = z3, z4 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   MARK(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   MARK(z) -{ 1 }-> 1 + MARK(z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   MARK(z) -{ 1 }-> 1 + MARK(z0) :|: z = 1 + z0, z0 >= 0
   MARK(z) -{ 1 }-> 1 + MARK(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   MARK(z) -{ 1 }-> 1 + A__U(mark(z0), z1, z2, z3) + MARK(z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 + z2 + z3, z2 >= 0, z3 >= 0
   MARK(z) -{ 1 }-> 1 + A__TAKE(mark(z0), mark(z1)) + MARK(z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   MARK(z) -{ 1 }-> 1 + A__TAKE(mark(z0), mark(z1)) + MARK(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   MARK(z) -{ 1 }-> 1 + A__TAIL(mark(z0)) + MARK(z0) :|: z = 1 + z0, z0 >= 0
   MARK(z) -{ 1 }-> 1 + A__SPLITAT(mark(z0), mark(z1)) + MARK(z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   MARK(z) -{ 1 }-> 1 + A__SPLITAT(mark(z0), mark(z1)) + MARK(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   MARK(z) -{ 1 }-> 1 + A__SND(mark(z0)) + MARK(z0) :|: z = 1 + z0, z0 >= 0
   MARK(z) -{ 1 }-> 1 + A__SEL(mark(z0), mark(z1)) + MARK(z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   MARK(z) -{ 1 }-> 1 + A__SEL(mark(z0), mark(z1)) + MARK(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   MARK(z) -{ 1 }-> 1 + A__NATSFROM(mark(z0)) + MARK(z0) :|: z = 1 + z0, z0 >= 0
   MARK(z) -{ 1 }-> 1 + A__HEAD(mark(z0)) + MARK(z0) :|: z = 1 + z0, z0 >= 0
   MARK(z) -{ 1 }-> 1 + A__FST(mark(z0)) + MARK(z0) :|: z = 1 + z0, z0 >= 0
   MARK(z) -{ 1 }-> 1 + A__AFTERNTH(mark(z0), mark(z1)) + MARK(z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   MARK(z) -{ 1 }-> 1 + A__AFTERNTH(mark(z0), mark(z1)) + MARK(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   a__afterNth(z, z') -{ 0 }-> a__snd(a__splitAt(mark(z0), mark(z1))) :|: z = z0, z1 >= 0, z' = z1, z0 >= 0
   a__afterNth(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   a__afterNth(z, z') -{ 0 }-> 1 + z0 + z1 :|: z = z0, z1 >= 0, z' = z1, z0 >= 0
   a__fst(z) -{ 0 }-> mark(z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   a__fst(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   a__fst(z) -{ 0 }-> 1 + z0 :|: z = z0, z0 >= 0
   a__head(z) -{ 0 }-> mark(z0) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   a__head(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   a__head(z) -{ 0 }-> 1 + z0 :|: z = z0, z0 >= 0
   a__natsFrom(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   a__natsFrom(z) -{ 0 }-> 1 + z0 :|: z = z0, z0 >= 0
   a__natsFrom(z) -{ 0 }-> 1 + mark(z0) + (1 + (1 + z0)) :|: z = z0, z0 >= 0
   a__sel(z, z') -{ 0 }-> a__head(a__afterNth(mark(z0), mark(z1))) :|: z = z0, z1 >= 0, z' = z1, z0 >= 0
   a__sel(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   a__sel(z, z') -{ 0 }-> 1 + z0 + z1 :|: z = z0, z1 >= 0, z' = z1, z0 >= 0
   a__snd(z) -{ 0 }-> mark(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   a__snd(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   a__snd(z) -{ 0 }-> 1 + z0 :|: z = z0, z0 >= 0
   a__splitAt(z, z') -{ 0 }-> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2) :|: z1 >= 0, z' = 1 + z1 + z2, z = 1 + z0, z0 >= 0, z2 >= 0
   a__splitAt(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   a__splitAt(z, z') -{ 0 }-> 1 + z0 + z1 :|: z = z0, z1 >= 0, z' = z1, z0 >= 0
   a__splitAt(z, z') -{ 0 }-> 1 + 1 + mark(z0) :|: z0 >= 0, z = 0, z' = z0
   a__tail(z) -{ 0 }-> mark(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   a__tail(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   a__tail(z) -{ 0 }-> 1 + z0 :|: z = z0, z0 >= 0
   a__take(z, z') -{ 0 }-> a__fst(a__splitAt(mark(z0), mark(z1))) :|: z = z0, z1 >= 0, z' = z1, z0 >= 0
   a__take(z, z') -{ 0 }-> 0 :|: v0 >= 0, v1 >= 0, z = v0, z' = v1
   a__take(z, z') -{ 0 }-> 1 + z0 + z1 :|: z = z0, z1 >= 0, z' = z1, z0 >= 0
   a__u(z, z', z'', z5) -{ 0 }-> 0 :|: z5 = v3, v0 >= 0, z'' = v2, v1 >= 0, z = v0, z' = v1, v2 >= 0, v3 >= 0
   a__u(z, z', z'', z5) -{ 0 }-> 1 + (1 + mark(z3) + z0) + mark(z1) :|: z1 >= 0, z5 = z4, z' = z2, z0 >= 0, z'' = z3, z4 >= 0, z = 1 + z0 + z1, z2 >= 0, z3 >= 0
   a__u(z, z', z'', z5) -{ 0 }-> 1 + z0 + z1 + z2 + z3 :|: z'' = z2, z = z0, z1 >= 0, z' = z1, z0 >= 0, z5 = z3, z2 >= 0, z3 >= 0
   mark(z) -{ 0 }-> a__u(mark(z0), z1, z2, z3) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1 + z2 + z3, z2 >= 0, z3 >= 0
   mark(z) -{ 0 }-> a__take(mark(z0), mark(z1)) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   mark(z) -{ 0 }-> a__tail(mark(z0)) :|: z = 1 + z0, z0 >= 0
   mark(z) -{ 0 }-> a__splitAt(mark(z0), mark(z1)) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   mark(z) -{ 0 }-> a__snd(mark(z0)) :|: z = 1 + z0, z0 >= 0
   mark(z) -{ 0 }-> a__sel(mark(z0), mark(z1)) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   mark(z) -{ 0 }-> a__natsFrom(mark(z0)) :|: z = 1 + z0, z0 >= 0
   mark(z) -{ 0 }-> a__head(mark(z0)) :|: z = 1 + z0, z0 >= 0
   mark(z) -{ 0 }-> a__fst(mark(z0)) :|: z = 1 + z0, z0 >= 0
   mark(z) -{ 0 }-> a__afterNth(mark(z0), mark(z1)) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   mark(z) -{ 0 }-> 1 :|: z = 1
   mark(z) -{ 0 }-> 0 :|: z = 0
   mark(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   mark(z) -{ 0 }-> 1 + mark(z0) :|: z = 1 + z0, z0 >= 0
   mark(z) -{ 0 }-> 1 + mark(z0) + z1 :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1
   mark(z) -{ 0 }-> 1 + mark(z0) + mark(z1) :|: z1 >= 0, z0 >= 0, z = 1 + z0 + z1

Only complete derivations are relevant for the runtime complexity.

----------------------------------------

(53) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace A__SPLITAT(s(z0), cons(z1, z2)) -> c7(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z0)) by 
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__U(splitAt(mark(x0), mark(x2)), x0, x1, x2), A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(0))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(nil))

----------------------------------------

(54)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c8(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z2))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__U(splitAt(mark(x0), mark(x2)), x0, x1, x2), A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(0))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(nil))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c8(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z2))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__U(splitAt(mark(x0), mark(x2)), x0, x1, x2), A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(0))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(nil))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2, MARK_1

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c8_3, c10_1, c11_1, c13_1, c15_1, c17_3, c18_3, c20_3, c21_3, c23_3, c24_3, c26_2, c27_2, c28_2, c29_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3


----------------------------------------

(55) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 3 trailing tuple parts
----------------------------------------

(56)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c8(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z2))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__SPLITAT(s(z0), cons(z1, z2)) -> c8(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z2))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2, MARK_1

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c8_3, c10_1, c11_1, c13_1, c15_1, c17_3, c18_3, c20_3, c21_3, c23_3, c24_3, c26_2, c27_2, c28_2, c29_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2


----------------------------------------

(57) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace A__SPLITAT(s(z0), cons(z1, z2)) -> c8(A__U(a__splitAt(mark(z0), mark(z2)), z0, z1, z2), A__SPLITAT(mark(z0), mark(z2)), MARK(z2)) by 
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__U(splitAt(mark(x0), mark(x2)), x0, x1, x2), A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(nil))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))

----------------------------------------

(58)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__U(splitAt(mark(x0), mark(x2)), x0, x1, x2), A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(nil))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__U(splitAt(mark(x0), mark(x2)), x0, x1, x2), A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(nil))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2, MARK_1

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c17_3, c18_3, c20_3, c21_3, c23_3, c24_3, c26_2, c27_2, c28_2, c29_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3


----------------------------------------

(59) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 3 trailing tuple parts
----------------------------------------

(60)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2, MARK_1

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c17_3, c18_3, c20_3, c21_3, c23_3, c24_3, c26_2, c27_2, c28_2, c29_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2


----------------------------------------

(61) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace A__SEL(z0, z1) -> c17(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z0)) by 
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, x1) -> c17(A__HEAD(afterNth(mark(x0), mark(x1))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(0))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(nil))

----------------------------------------

(62)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, x1) -> c17(A__HEAD(afterNth(mark(x0), mark(x1))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(0))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(nil))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, x1) -> c17(A__HEAD(afterNth(mark(x0), mark(x1))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(0))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(nil))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2, MARK_1

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c18_3, c20_3, c21_3, c23_3, c24_3, c26_2, c27_2, c28_2, c29_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3


----------------------------------------

(63) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 3 trailing tuple parts
----------------------------------------

(64)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2, MARK_1

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c18_3, c20_3, c21_3, c23_3, c24_3, c26_2, c27_2, c28_2, c29_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2


----------------------------------------

(65) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace A__SEL(z0, z1) -> c18(A__HEAD(a__afterNth(mark(z0), mark(z1))), A__AFTERNTH(mark(z0), mark(z1)), MARK(z1)) by 
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__HEAD(afterNth(mark(x0), mark(x1))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(0))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(nil))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))

----------------------------------------

(66)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__HEAD(afterNth(mark(x0), mark(x1))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(0))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(nil))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__HEAD(afterNth(mark(x0), mark(x1))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(0))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(nil))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, A__TAKE_2, A__AFTERNTH_2, MARK_1, A__SEL_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c20_3, c21_3, c23_3, c24_3, c26_2, c27_2, c28_2, c29_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3


----------------------------------------

(67) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 3 trailing tuple parts
----------------------------------------

(68)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, A__TAKE_2, A__AFTERNTH_2, MARK_1, A__SEL_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c20_3, c21_3, c23_3, c24_3, c26_2, c27_2, c28_2, c29_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2


----------------------------------------

(69) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace A__TAKE(z0, z1) -> c20(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0)) by 
   A__TAKE(x0, x1) -> c20(A__FST(splitAt(mark(x0), mark(x1))), A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(0))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(nil))

----------------------------------------

(70)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, x1) -> c20(A__FST(splitAt(mark(x0), mark(x1))), A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(0))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(nil))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, x1) -> c20(A__FST(splitAt(mark(x0), mark(x1))), A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(0))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(nil))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, A__TAKE_2, A__AFTERNTH_2, MARK_1, A__SEL_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c21_3, c23_3, c24_3, c26_2, c27_2, c28_2, c29_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3


----------------------------------------

(71) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 3 trailing tuple parts
----------------------------------------

(72)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, A__TAKE_2, A__AFTERNTH_2, MARK_1, A__SEL_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c21_3, c23_3, c24_3, c26_2, c27_2, c28_2, c29_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2


----------------------------------------

(73) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace A__TAKE(z0, z1) -> c21(A__FST(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1)) by 
   A__TAKE(x0, x1) -> c21(A__FST(splitAt(mark(x0), mark(x1))), A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(0))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(nil))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))

----------------------------------------

(74)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, x1) -> c21(A__FST(splitAt(mark(x0), mark(x1))), A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(0))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(nil))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, x1) -> c21(A__FST(splitAt(mark(x0), mark(x1))), A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(0))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(nil))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, A__AFTERNTH_2, MARK_1, A__SEL_2, A__TAKE_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c23_3, c24_3, c26_2, c27_2, c28_2, c29_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3


----------------------------------------

(75) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 3 trailing tuple parts
----------------------------------------

(76)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, A__AFTERNTH_2, MARK_1, A__SEL_2, A__TAKE_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c23_3, c24_3, c26_2, c27_2, c28_2, c29_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2


----------------------------------------

(77) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace A__AFTERNTH(z0, z1) -> c23(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z0)) by 
   A__AFTERNTH(x0, x1) -> c23(A__SND(splitAt(mark(x0), mark(x1))), A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(0))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(nil))

----------------------------------------

(78)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, x1) -> c23(A__SND(splitAt(mark(x0), mark(x1))), A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(0))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(nil))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, x1) -> c23(A__SND(splitAt(mark(x0), mark(x1))), A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(0))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(nil))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, A__AFTERNTH_2, MARK_1, A__SEL_2, A__TAKE_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c24_3, c26_2, c27_2, c28_2, c29_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3


----------------------------------------

(79) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 3 trailing tuple parts
----------------------------------------

(80)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, A__AFTERNTH_2, MARK_1, A__SEL_2, A__TAKE_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c24_3, c26_2, c27_2, c28_2, c29_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2


----------------------------------------

(81) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace A__AFTERNTH(z0, z1) -> c24(A__SND(a__splitAt(mark(z0), mark(z1))), A__SPLITAT(mark(z0), mark(z1)), MARK(z1)) by 
   A__AFTERNTH(x0, x1) -> c24(A__SND(splitAt(mark(x0), mark(x1))), A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(0))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(nil))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))

----------------------------------------

(82)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, x1) -> c24(A__SND(splitAt(mark(x0), mark(x1))), A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(0))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(nil))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, x1) -> c24(A__SND(splitAt(mark(x0), mark(x1))), A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(0))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(nil))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c27_2, c28_2, c29_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3


----------------------------------------

(83) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 3 trailing tuple parts
----------------------------------------

(84)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c27_2, c28_2, c29_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2


----------------------------------------

(85) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MARK(fst(z0)) -> c27(A__FST(mark(z0)), MARK(z0)) by 
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(A__FST(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(A__FST(s(mark(z0))), MARK(s(z0)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(0)) -> c27(A__FST(0), MARK(0))
   MARK(fst(nil)) -> c27(A__FST(nil), MARK(nil))

----------------------------------------

(86)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(A__FST(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(A__FST(s(mark(z0))), MARK(s(z0)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(0)) -> c27(A__FST(0), MARK(0))
   MARK(fst(nil)) -> c27(A__FST(nil), MARK(nil))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(A__FST(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(A__FST(s(mark(z0))), MARK(s(z0)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(0)) -> c27(A__FST(0), MARK(0))
   MARK(fst(nil)) -> c27(A__FST(nil), MARK(nil))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c28_2, c29_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2


----------------------------------------

(87) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing nodes:
   MARK(fst(0)) -> c27(A__FST(0), MARK(0))
   MARK(fst(nil)) -> c27(A__FST(nil), MARK(nil))

----------------------------------------

(88)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(A__FST(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(A__FST(s(mark(z0))), MARK(s(z0)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(A__FST(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(A__FST(s(mark(z0))), MARK(s(z0)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c28_2, c29_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2


----------------------------------------

(89) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing tuple parts
----------------------------------------

(90)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c28_2, c29_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1


----------------------------------------

(91) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MARK(snd(z0)) -> c28(A__SND(mark(z0)), MARK(z0)) by 
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(A__SND(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(A__SND(s(mark(z0))), MARK(s(z0)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(0)) -> c28(A__SND(0), MARK(0))
   MARK(snd(nil)) -> c28(A__SND(nil), MARK(nil))

----------------------------------------

(92)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(A__SND(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(A__SND(s(mark(z0))), MARK(s(z0)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(0)) -> c28(A__SND(0), MARK(0))
   MARK(snd(nil)) -> c28(A__SND(nil), MARK(nil))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(A__SND(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(A__SND(s(mark(z0))), MARK(s(z0)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(0)) -> c28(A__SND(0), MARK(0))
   MARK(snd(nil)) -> c28(A__SND(nil), MARK(nil))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c29_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2


----------------------------------------

(93) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing nodes:
   MARK(snd(0)) -> c28(A__SND(0), MARK(0))
   MARK(snd(nil)) -> c28(A__SND(nil), MARK(nil))

----------------------------------------

(94)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(A__SND(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(A__SND(s(mark(z0))), MARK(s(z0)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(A__SND(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(A__SND(s(mark(z0))), MARK(s(z0)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c29_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2


----------------------------------------

(95) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing tuple parts
----------------------------------------

(96)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c29_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1


----------------------------------------

(97) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MARK(splitAt(z0, z1)) -> c29(A__SPLITAT(mark(z0), mark(z1)), MARK(z0)) by 
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(A__SPLITAT(cons(mark(z0), z1), mark(x1)), MARK(cons(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(A__SPLITAT(pair(mark(z0), mark(z1)), mark(x1)), MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)), MARK(0))
   MARK(splitAt(nil, x1)) -> c29(A__SPLITAT(nil, mark(x1)), MARK(nil))

----------------------------------------

(98)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(A__SPLITAT(cons(mark(z0), z1), mark(x1)), MARK(cons(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(A__SPLITAT(pair(mark(z0), mark(z1)), mark(x1)), MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)), MARK(0))
   MARK(splitAt(nil, x1)) -> c29(A__SPLITAT(nil, mark(x1)), MARK(nil))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(A__SPLITAT(cons(mark(z0), z1), mark(x1)), MARK(cons(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(A__SPLITAT(pair(mark(z0), mark(z1)), mark(x1)), MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)), MARK(0))
   MARK(splitAt(nil, x1)) -> c29(A__SPLITAT(nil, mark(x1)), MARK(nil))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2


----------------------------------------

(99) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   MARK(splitAt(nil, x1)) -> c29(A__SPLITAT(nil, mark(x1)), MARK(nil))

----------------------------------------

(100)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(A__SPLITAT(cons(mark(z0), z1), mark(x1)), MARK(cons(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(A__SPLITAT(pair(mark(z0), mark(z1)), mark(x1)), MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)), MARK(0))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(A__SPLITAT(cons(mark(z0), z1), mark(x1)), MARK(cons(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(A__SPLITAT(pair(mark(z0), mark(z1)), mark(x1)), MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)), MARK(0))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2


----------------------------------------

(101) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 3 trailing tuple parts
----------------------------------------

(102)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c30_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1


----------------------------------------

(103) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MARK(splitAt(z0, z1)) -> c30(A__SPLITAT(mark(z0), mark(z1)), MARK(z1)) by 
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0), MARK(0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil), MARK(nil))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(A__SPLITAT(cons(mark(z0), z1), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(A__SPLITAT(pair(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(A__SPLITAT(nil, mark(x1)), MARK(x1))

----------------------------------------

(104)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0), MARK(0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil), MARK(nil))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(A__SPLITAT(cons(mark(z0), z1), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(A__SPLITAT(pair(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(A__SPLITAT(nil, mark(x1)), MARK(x1))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0), MARK(0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil), MARK(nil))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(A__SPLITAT(cons(mark(z0), z1), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(A__SPLITAT(pair(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(A__SPLITAT(nil, mark(x1)), MARK(x1))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2


----------------------------------------

(105) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 5 trailing tuple parts
----------------------------------------

(106)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c31_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1


----------------------------------------

(107) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MARK(u(z0, z1, z2, z3)) -> c31(A__U(mark(z0), z1, z2, z3), MARK(z0)) by 
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(A__U(cons(mark(z0), z1), x1, x2, x3), MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(A__U(s(mark(z0)), x1, x2, x3), MARK(s(z0)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(0, x1, x2, x3)) -> c31(A__U(0, x1, x2, x3), MARK(0))
   MARK(u(nil, x1, x2, x3)) -> c31(A__U(nil, x1, x2, x3), MARK(nil))

----------------------------------------

(108)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(A__U(cons(mark(z0), z1), x1, x2, x3), MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(A__U(s(mark(z0)), x1, x2, x3), MARK(s(z0)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(0, x1, x2, x3)) -> c31(A__U(0, x1, x2, x3), MARK(0))
   MARK(u(nil, x1, x2, x3)) -> c31(A__U(nil, x1, x2, x3), MARK(nil))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(A__U(cons(mark(z0), z1), x1, x2, x3), MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(A__U(s(mark(z0)), x1, x2, x3), MARK(s(z0)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(0, x1, x2, x3)) -> c31(A__U(0, x1, x2, x3), MARK(0))
   MARK(u(nil, x1, x2, x3)) -> c31(A__U(nil, x1, x2, x3), MARK(nil))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2


----------------------------------------

(109) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing nodes:
   MARK(u(nil, x1, x2, x3)) -> c31(A__U(nil, x1, x2, x3), MARK(nil))
   MARK(u(0, x1, x2, x3)) -> c31(A__U(0, x1, x2, x3), MARK(0))

----------------------------------------

(110)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(A__U(cons(mark(z0), z1), x1, x2, x3), MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(A__U(s(mark(z0)), x1, x2, x3), MARK(s(z0)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(A__U(cons(mark(z0), z1), x1, x2, x3), MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(A__U(s(mark(z0)), x1, x2, x3), MARK(s(z0)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2


----------------------------------------

(111) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing tuple parts
----------------------------------------

(112)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c32_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1


----------------------------------------

(113) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MARK(head(z0)) -> c32(A__HEAD(mark(z0)), MARK(z0)) by 
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(A__HEAD(s(mark(z0))), MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(A__HEAD(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(head(0)) -> c32(A__HEAD(0), MARK(0))
   MARK(head(nil)) -> c32(A__HEAD(nil), MARK(nil))

----------------------------------------

(114)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(A__HEAD(s(mark(z0))), MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(A__HEAD(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(head(0)) -> c32(A__HEAD(0), MARK(0))
   MARK(head(nil)) -> c32(A__HEAD(nil), MARK(nil))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(A__HEAD(s(mark(z0))), MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(A__HEAD(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(head(0)) -> c32(A__HEAD(0), MARK(0))
   MARK(head(nil)) -> c32(A__HEAD(nil), MARK(nil))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2


----------------------------------------

(115) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing nodes:
   MARK(head(0)) -> c32(A__HEAD(0), MARK(0))
   MARK(head(nil)) -> c32(A__HEAD(nil), MARK(nil))

----------------------------------------

(116)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(A__HEAD(s(mark(z0))), MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(A__HEAD(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(A__HEAD(s(mark(z0))), MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(A__HEAD(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2


----------------------------------------

(117) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing tuple parts
----------------------------------------

(118)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c33_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1


----------------------------------------

(119) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace MARK(tail(z0)) -> c33(A__TAIL(mark(z0)), MARK(z0)) by 
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(A__TAIL(s(mark(z0))), MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(A__TAIL(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(tail(0)) -> c33(A__TAIL(0), MARK(0))
   MARK(tail(nil)) -> c33(A__TAIL(nil), MARK(nil))

----------------------------------------

(120)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(A__TAIL(s(mark(z0))), MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(A__TAIL(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(tail(0)) -> c33(A__TAIL(0), MARK(0))
   MARK(tail(nil)) -> c33(A__TAIL(nil), MARK(nil))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(A__TAIL(s(mark(z0))), MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(A__TAIL(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(tail(0)) -> c33(A__TAIL(0), MARK(0))
   MARK(tail(nil)) -> c33(A__TAIL(nil), MARK(nil))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1, c33_2


----------------------------------------

(121) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing nodes:
   MARK(tail(nil)) -> c33(A__TAIL(nil), MARK(nil))
   MARK(tail(0)) -> c33(A__TAIL(0), MARK(0))

----------------------------------------

(122)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(A__TAIL(s(mark(z0))), MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(A__TAIL(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(A__TAIL(s(mark(z0))), MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(A__TAIL(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1, c33_2


----------------------------------------

(123) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 2 trailing tuple parts
----------------------------------------

(124)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1, c33_2, c33_1


----------------------------------------

(125) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0)) by 
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(splitAt(mark(x0), a__natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))

----------------------------------------

(126)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(splitAt(mark(x0), a__natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(splitAt(mark(x0), a__natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1, c33_2, c33_1, c7_1


----------------------------------------

(127) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 3 trailing tuple parts
----------------------------------------

(128)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1, c33_2, c33_1, c7_1


----------------------------------------

(129) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0)) by 
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(splitAt(mark(x0), a__fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))

----------------------------------------

(130)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(splitAt(mark(x0), a__fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(splitAt(mark(x0), a__fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1, c33_2, c33_1, c7_1


----------------------------------------

(131) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 3 trailing tuple parts
----------------------------------------

(132)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1, c33_2, c33_1, c7_1


----------------------------------------

(133) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0)) by 
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(splitAt(mark(x0), a__snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))

----------------------------------------

(134)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(splitAt(mark(x0), a__snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(splitAt(mark(x0), a__snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1, c33_2, c33_1, c7_1


----------------------------------------

(135) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 3 trailing tuple parts
----------------------------------------

(136)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1, c33_2, c33_1, c7_1


----------------------------------------

(137) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0)) by 
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(splitAt(mark(x0), a__splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))

----------------------------------------

(138)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(splitAt(mark(x0), a__splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(splitAt(mark(x0), a__splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1, c33_2, c33_1, c7_1


----------------------------------------

(139) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 3 trailing tuple parts
----------------------------------------

(140)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1, c33_2, c33_1, c7_1


----------------------------------------

(141) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0)) by 
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(splitAt(mark(x0), a__u(mark(x2), x3, x4, x5)), x0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))

----------------------------------------

(142)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(splitAt(mark(x0), a__u(mark(x2), x3, x4, x5)), x0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(splitAt(mark(x0), a__u(mark(x2), x3, x4, x5)), x0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1, c33_2, c33_1, c7_1


----------------------------------------

(143) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 3 trailing tuple parts
----------------------------------------

(144)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1, c33_2, c33_1, c7_1


----------------------------------------

(145) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace A__SPLITAT(s(x0), cons(x1, head(z0))) -> c7(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0)) by 
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(splitAt(mark(x0), a__head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(mark(x0), head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__natsFrom(mark(z0)))), x0, x1, head(natsFrom(z0))), A__SPLITAT(mark(x0), mark(head(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__fst(mark(z0)))), x0, x1, head(fst(z0))), A__SPLITAT(mark(x0), mark(head(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__snd(mark(z0)))), x0, x1, head(snd(z0))), A__SPLITAT(mark(x0), mark(head(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__splitAt(mark(z0), mark(z1)))), x0, x1, head(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(head(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__u(mark(z0), z1, z2, z3))), x0, x1, head(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(head(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__head(mark(z0)))), x0, x1, head(head(z0))), A__SPLITAT(mark(x0), mark(head(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__tail(mark(z0)))), x0, x1, head(tail(z0))), A__SPLITAT(mark(x0), mark(head(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__sel(mark(z0), mark(z1)))), x0, x1, head(sel(z0, z1))), A__SPLITAT(mark(x0), mark(head(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(z0), mark(z1)))), x0, x1, head(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(head(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__take(mark(z0), mark(z1)))), x0, x1, head(take(z0, z1))), A__SPLITAT(mark(x0), mark(head(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(cons(mark(z0), z1))), x0, x1, head(cons(z0, z1))), A__SPLITAT(mark(x0), mark(head(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(s(mark(z0)))), x0, x1, head(s(z0))), A__SPLITAT(mark(x0), mark(head(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(pair(mark(z0), mark(z1)))), x0, x1, head(pair(z0, z1))), A__SPLITAT(mark(x0), mark(head(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(0))) -> c7(A__U(a__splitAt(mark(x0), a__head(0)), x0, x1, head(0)), A__SPLITAT(mark(x0), mark(head(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(nil))) -> c7(A__U(a__splitAt(mark(x0), a__head(nil)), x0, x1, head(nil)), A__SPLITAT(mark(x0), mark(head(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__head(mark(x2))), natsFrom(z0), x1, head(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(head(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__head(mark(x2))), fst(z0), x1, head(x2)), A__SPLITAT(mark(fst(z0)), mark(head(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__head(mark(x2))), snd(z0), x1, head(x2)), A__SPLITAT(mark(snd(z0)), mark(head(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__head(mark(x2))), splitAt(z0, z1), x1, head(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(head(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__head(mark(x2))), u(z0, z1, z2, z3), x1, head(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(head(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__head(mark(x2))), head(z0), x1, head(x2)), A__SPLITAT(mark(head(z0)), mark(head(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__head(mark(x2))), tail(z0), x1, head(x2)), A__SPLITAT(mark(tail(z0)), mark(head(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__head(mark(x2))), sel(z0, z1), x1, head(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(head(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__head(mark(x2))), afterNth(z0, z1), x1, head(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(head(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__head(mark(x2))), take(z0, z1), x1, head(x2)), A__SPLITAT(mark(take(z0, z1)), mark(head(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__head(mark(x2))), cons(z0, z1), x1, head(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(head(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__head(mark(x2))), s(z0), x1, head(x2)), A__SPLITAT(mark(s(z0)), mark(head(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__head(mark(x2))), pair(z0, z1), x1, head(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(head(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(0, a__head(mark(x2))), 0, x1, head(x2)), A__SPLITAT(mark(0), mark(head(x2))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, head(x2))) -> c7(A__U(a__splitAt(nil, a__head(mark(x2))), nil, x1, head(x2)), A__SPLITAT(mark(nil), mark(head(x2))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))))

----------------------------------------

(146)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(splitAt(mark(x0), a__head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(mark(x0), head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__natsFrom(mark(z0)))), x0, x1, head(natsFrom(z0))), A__SPLITAT(mark(x0), mark(head(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__fst(mark(z0)))), x0, x1, head(fst(z0))), A__SPLITAT(mark(x0), mark(head(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__snd(mark(z0)))), x0, x1, head(snd(z0))), A__SPLITAT(mark(x0), mark(head(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__splitAt(mark(z0), mark(z1)))), x0, x1, head(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(head(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__u(mark(z0), z1, z2, z3))), x0, x1, head(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(head(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__head(mark(z0)))), x0, x1, head(head(z0))), A__SPLITAT(mark(x0), mark(head(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__tail(mark(z0)))), x0, x1, head(tail(z0))), A__SPLITAT(mark(x0), mark(head(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__sel(mark(z0), mark(z1)))), x0, x1, head(sel(z0, z1))), A__SPLITAT(mark(x0), mark(head(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(z0), mark(z1)))), x0, x1, head(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(head(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__take(mark(z0), mark(z1)))), x0, x1, head(take(z0, z1))), A__SPLITAT(mark(x0), mark(head(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(cons(mark(z0), z1))), x0, x1, head(cons(z0, z1))), A__SPLITAT(mark(x0), mark(head(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(s(mark(z0)))), x0, x1, head(s(z0))), A__SPLITAT(mark(x0), mark(head(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(pair(mark(z0), mark(z1)))), x0, x1, head(pair(z0, z1))), A__SPLITAT(mark(x0), mark(head(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(0))) -> c7(A__U(a__splitAt(mark(x0), a__head(0)), x0, x1, head(0)), A__SPLITAT(mark(x0), mark(head(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(nil))) -> c7(A__U(a__splitAt(mark(x0), a__head(nil)), x0, x1, head(nil)), A__SPLITAT(mark(x0), mark(head(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__head(mark(x2))), natsFrom(z0), x1, head(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(head(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__head(mark(x2))), fst(z0), x1, head(x2)), A__SPLITAT(mark(fst(z0)), mark(head(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__head(mark(x2))), snd(z0), x1, head(x2)), A__SPLITAT(mark(snd(z0)), mark(head(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__head(mark(x2))), splitAt(z0, z1), x1, head(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(head(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__head(mark(x2))), u(z0, z1, z2, z3), x1, head(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(head(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__head(mark(x2))), head(z0), x1, head(x2)), A__SPLITAT(mark(head(z0)), mark(head(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__head(mark(x2))), tail(z0), x1, head(x2)), A__SPLITAT(mark(tail(z0)), mark(head(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__head(mark(x2))), sel(z0, z1), x1, head(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(head(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__head(mark(x2))), afterNth(z0, z1), x1, head(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(head(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__head(mark(x2))), take(z0, z1), x1, head(x2)), A__SPLITAT(mark(take(z0, z1)), mark(head(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__head(mark(x2))), cons(z0, z1), x1, head(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(head(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__head(mark(x2))), s(z0), x1, head(x2)), A__SPLITAT(mark(s(z0)), mark(head(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__head(mark(x2))), pair(z0, z1), x1, head(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(head(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(0, a__head(mark(x2))), 0, x1, head(x2)), A__SPLITAT(mark(0), mark(head(x2))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, head(x2))) -> c7(A__U(a__splitAt(nil, a__head(mark(x2))), nil, x1, head(x2)), A__SPLITAT(mark(nil), mark(head(x2))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(splitAt(mark(x0), a__head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(mark(x0), head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__natsFrom(mark(z0)))), x0, x1, head(natsFrom(z0))), A__SPLITAT(mark(x0), mark(head(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__fst(mark(z0)))), x0, x1, head(fst(z0))), A__SPLITAT(mark(x0), mark(head(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__snd(mark(z0)))), x0, x1, head(snd(z0))), A__SPLITAT(mark(x0), mark(head(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__splitAt(mark(z0), mark(z1)))), x0, x1, head(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(head(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__u(mark(z0), z1, z2, z3))), x0, x1, head(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(head(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__head(mark(z0)))), x0, x1, head(head(z0))), A__SPLITAT(mark(x0), mark(head(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__tail(mark(z0)))), x0, x1, head(tail(z0))), A__SPLITAT(mark(x0), mark(head(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__sel(mark(z0), mark(z1)))), x0, x1, head(sel(z0, z1))), A__SPLITAT(mark(x0), mark(head(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(z0), mark(z1)))), x0, x1, head(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(head(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__take(mark(z0), mark(z1)))), x0, x1, head(take(z0, z1))), A__SPLITAT(mark(x0), mark(head(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(cons(mark(z0), z1))), x0, x1, head(cons(z0, z1))), A__SPLITAT(mark(x0), mark(head(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(s(mark(z0)))), x0, x1, head(s(z0))), A__SPLITAT(mark(x0), mark(head(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(pair(mark(z0), mark(z1)))), x0, x1, head(pair(z0, z1))), A__SPLITAT(mark(x0), mark(head(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(0))) -> c7(A__U(a__splitAt(mark(x0), a__head(0)), x0, x1, head(0)), A__SPLITAT(mark(x0), mark(head(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(nil))) -> c7(A__U(a__splitAt(mark(x0), a__head(nil)), x0, x1, head(nil)), A__SPLITAT(mark(x0), mark(head(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__head(mark(x2))), natsFrom(z0), x1, head(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(head(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__head(mark(x2))), fst(z0), x1, head(x2)), A__SPLITAT(mark(fst(z0)), mark(head(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__head(mark(x2))), snd(z0), x1, head(x2)), A__SPLITAT(mark(snd(z0)), mark(head(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__head(mark(x2))), splitAt(z0, z1), x1, head(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(head(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__head(mark(x2))), u(z0, z1, z2, z3), x1, head(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(head(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__head(mark(x2))), head(z0), x1, head(x2)), A__SPLITAT(mark(head(z0)), mark(head(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__head(mark(x2))), tail(z0), x1, head(x2)), A__SPLITAT(mark(tail(z0)), mark(head(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__head(mark(x2))), sel(z0, z1), x1, head(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(head(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__head(mark(x2))), afterNth(z0, z1), x1, head(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(head(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__head(mark(x2))), take(z0, z1), x1, head(x2)), A__SPLITAT(mark(take(z0, z1)), mark(head(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__head(mark(x2))), cons(z0, z1), x1, head(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(head(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__head(mark(x2))), s(z0), x1, head(x2)), A__SPLITAT(mark(s(z0)), mark(head(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__head(mark(x2))), pair(z0, z1), x1, head(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(head(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(0, a__head(mark(x2))), 0, x1, head(x2)), A__SPLITAT(mark(0), mark(head(x2))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, head(x2))) -> c7(A__U(a__splitAt(nil, a__head(mark(x2))), nil, x1, head(x2)), A__SPLITAT(mark(nil), mark(head(x2))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1, c33_2, c33_1, c7_1


----------------------------------------

(147) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 3 trailing tuple parts
----------------------------------------

(148)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(mark(x0), head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__natsFrom(mark(z0)))), x0, x1, head(natsFrom(z0))), A__SPLITAT(mark(x0), mark(head(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__fst(mark(z0)))), x0, x1, head(fst(z0))), A__SPLITAT(mark(x0), mark(head(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__snd(mark(z0)))), x0, x1, head(snd(z0))), A__SPLITAT(mark(x0), mark(head(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__splitAt(mark(z0), mark(z1)))), x0, x1, head(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(head(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__u(mark(z0), z1, z2, z3))), x0, x1, head(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(head(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__head(mark(z0)))), x0, x1, head(head(z0))), A__SPLITAT(mark(x0), mark(head(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__tail(mark(z0)))), x0, x1, head(tail(z0))), A__SPLITAT(mark(x0), mark(head(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__sel(mark(z0), mark(z1)))), x0, x1, head(sel(z0, z1))), A__SPLITAT(mark(x0), mark(head(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(z0), mark(z1)))), x0, x1, head(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(head(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__take(mark(z0), mark(z1)))), x0, x1, head(take(z0, z1))), A__SPLITAT(mark(x0), mark(head(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(cons(mark(z0), z1))), x0, x1, head(cons(z0, z1))), A__SPLITAT(mark(x0), mark(head(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(s(mark(z0)))), x0, x1, head(s(z0))), A__SPLITAT(mark(x0), mark(head(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(pair(mark(z0), mark(z1)))), x0, x1, head(pair(z0, z1))), A__SPLITAT(mark(x0), mark(head(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(0))) -> c7(A__U(a__splitAt(mark(x0), a__head(0)), x0, x1, head(0)), A__SPLITAT(mark(x0), mark(head(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(nil))) -> c7(A__U(a__splitAt(mark(x0), a__head(nil)), x0, x1, head(nil)), A__SPLITAT(mark(x0), mark(head(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__head(mark(x2))), natsFrom(z0), x1, head(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(head(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__head(mark(x2))), fst(z0), x1, head(x2)), A__SPLITAT(mark(fst(z0)), mark(head(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__head(mark(x2))), snd(z0), x1, head(x2)), A__SPLITAT(mark(snd(z0)), mark(head(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__head(mark(x2))), splitAt(z0, z1), x1, head(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(head(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__head(mark(x2))), u(z0, z1, z2, z3), x1, head(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(head(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__head(mark(x2))), head(z0), x1, head(x2)), A__SPLITAT(mark(head(z0)), mark(head(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__head(mark(x2))), tail(z0), x1, head(x2)), A__SPLITAT(mark(tail(z0)), mark(head(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__head(mark(x2))), sel(z0, z1), x1, head(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(head(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__head(mark(x2))), afterNth(z0, z1), x1, head(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(head(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__head(mark(x2))), take(z0, z1), x1, head(x2)), A__SPLITAT(mark(take(z0, z1)), mark(head(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__head(mark(x2))), cons(z0, z1), x1, head(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(head(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__head(mark(x2))), s(z0), x1, head(x2)), A__SPLITAT(mark(s(z0)), mark(head(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__head(mark(x2))), pair(z0, z1), x1, head(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(head(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(0, a__head(mark(x2))), 0, x1, head(x2)), A__SPLITAT(mark(0), mark(head(x2))))
   A__SPLITAT(s(nil), cons(x1, head(x2))) -> c7(A__U(a__splitAt(nil, a__head(mark(x2))), nil, x1, head(x2)), A__SPLITAT(mark(nil), mark(head(x2))))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(mark(x0), head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__natsFrom(mark(z0)))), x0, x1, head(natsFrom(z0))), A__SPLITAT(mark(x0), mark(head(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__fst(mark(z0)))), x0, x1, head(fst(z0))), A__SPLITAT(mark(x0), mark(head(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__snd(mark(z0)))), x0, x1, head(snd(z0))), A__SPLITAT(mark(x0), mark(head(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__splitAt(mark(z0), mark(z1)))), x0, x1, head(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(head(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__u(mark(z0), z1, z2, z3))), x0, x1, head(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(head(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__head(mark(z0)))), x0, x1, head(head(z0))), A__SPLITAT(mark(x0), mark(head(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__tail(mark(z0)))), x0, x1, head(tail(z0))), A__SPLITAT(mark(x0), mark(head(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__sel(mark(z0), mark(z1)))), x0, x1, head(sel(z0, z1))), A__SPLITAT(mark(x0), mark(head(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(z0), mark(z1)))), x0, x1, head(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(head(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__take(mark(z0), mark(z1)))), x0, x1, head(take(z0, z1))), A__SPLITAT(mark(x0), mark(head(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(cons(mark(z0), z1))), x0, x1, head(cons(z0, z1))), A__SPLITAT(mark(x0), mark(head(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(s(mark(z0)))), x0, x1, head(s(z0))), A__SPLITAT(mark(x0), mark(head(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(pair(mark(z0), mark(z1)))), x0, x1, head(pair(z0, z1))), A__SPLITAT(mark(x0), mark(head(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(0))) -> c7(A__U(a__splitAt(mark(x0), a__head(0)), x0, x1, head(0)), A__SPLITAT(mark(x0), mark(head(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(nil))) -> c7(A__U(a__splitAt(mark(x0), a__head(nil)), x0, x1, head(nil)), A__SPLITAT(mark(x0), mark(head(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__head(mark(x2))), natsFrom(z0), x1, head(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(head(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__head(mark(x2))), fst(z0), x1, head(x2)), A__SPLITAT(mark(fst(z0)), mark(head(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__head(mark(x2))), snd(z0), x1, head(x2)), A__SPLITAT(mark(snd(z0)), mark(head(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__head(mark(x2))), splitAt(z0, z1), x1, head(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(head(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__head(mark(x2))), u(z0, z1, z2, z3), x1, head(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(head(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__head(mark(x2))), head(z0), x1, head(x2)), A__SPLITAT(mark(head(z0)), mark(head(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__head(mark(x2))), tail(z0), x1, head(x2)), A__SPLITAT(mark(tail(z0)), mark(head(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__head(mark(x2))), sel(z0, z1), x1, head(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(head(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__head(mark(x2))), afterNth(z0, z1), x1, head(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(head(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__head(mark(x2))), take(z0, z1), x1, head(x2)), A__SPLITAT(mark(take(z0, z1)), mark(head(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__head(mark(x2))), cons(z0, z1), x1, head(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(head(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__head(mark(x2))), s(z0), x1, head(x2)), A__SPLITAT(mark(s(z0)), mark(head(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__head(mark(x2))), pair(z0, z1), x1, head(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(head(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(0, a__head(mark(x2))), 0, x1, head(x2)), A__SPLITAT(mark(0), mark(head(x2))))
   A__SPLITAT(s(nil), cons(x1, head(x2))) -> c7(A__U(a__splitAt(nil, a__head(mark(x2))), nil, x1, head(x2)), A__SPLITAT(mark(nil), mark(head(x2))))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1, c33_2, c33_1, c7_1


----------------------------------------

(149) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0)) by 
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__U(splitAt(mark(x0), a__tail(mark(x2))), x0, x1, tail(x2)), A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(mark(x0), tail(mark(x2))), x0, x1, tail(x2)), A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__natsFrom(mark(z0)))), x0, x1, tail(natsFrom(z0))), A__SPLITAT(mark(x0), mark(tail(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__fst(mark(z0)))), x0, x1, tail(fst(z0))), A__SPLITAT(mark(x0), mark(tail(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__snd(mark(z0)))), x0, x1, tail(snd(z0))), A__SPLITAT(mark(x0), mark(tail(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__splitAt(mark(z0), mark(z1)))), x0, x1, tail(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(tail(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__u(mark(z0), z1, z2, z3))), x0, x1, tail(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(tail(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__head(mark(z0)))), x0, x1, tail(head(z0))), A__SPLITAT(mark(x0), mark(tail(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__tail(mark(z0)))), x0, x1, tail(tail(z0))), A__SPLITAT(mark(x0), mark(tail(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__sel(mark(z0), mark(z1)))), x0, x1, tail(sel(z0, z1))), A__SPLITAT(mark(x0), mark(tail(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__afterNth(mark(z0), mark(z1)))), x0, x1, tail(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(tail(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__take(mark(z0), mark(z1)))), x0, x1, tail(take(z0, z1))), A__SPLITAT(mark(x0), mark(tail(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(cons(mark(z0), z1))), x0, x1, tail(cons(z0, z1))), A__SPLITAT(mark(x0), mark(tail(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(s(mark(z0)))), x0, x1, tail(s(z0))), A__SPLITAT(mark(x0), mark(tail(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(pair(mark(z0), mark(z1)))), x0, x1, tail(pair(z0, z1))), A__SPLITAT(mark(x0), mark(tail(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(0)), x0, x1, tail(0)), A__SPLITAT(mark(x0), mark(tail(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(nil))) -> c7(A__U(a__splitAt(mark(x0), a__tail(nil)), x0, x1, tail(nil)), A__SPLITAT(mark(x0), mark(tail(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__tail(mark(x2))), natsFrom(z0), x1, tail(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(tail(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__tail(mark(x2))), fst(z0), x1, tail(x2)), A__SPLITAT(mark(fst(z0)), mark(tail(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__tail(mark(x2))), snd(z0), x1, tail(x2)), A__SPLITAT(mark(snd(z0)), mark(tail(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__tail(mark(x2))), splitAt(z0, z1), x1, tail(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(tail(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__tail(mark(x2))), u(z0, z1, z2, z3), x1, tail(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(tail(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__tail(mark(x2))), head(z0), x1, tail(x2)), A__SPLITAT(mark(head(z0)), mark(tail(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__tail(mark(x2))), tail(z0), x1, tail(x2)), A__SPLITAT(mark(tail(z0)), mark(tail(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__tail(mark(x2))), sel(z0, z1), x1, tail(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(tail(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__tail(mark(x2))), afterNth(z0, z1), x1, tail(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(tail(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__tail(mark(x2))), take(z0, z1), x1, tail(x2)), A__SPLITAT(mark(take(z0, z1)), mark(tail(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__tail(mark(x2))), cons(z0, z1), x1, tail(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(tail(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__tail(mark(x2))), s(z0), x1, tail(x2)), A__SPLITAT(mark(s(z0)), mark(tail(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__tail(mark(x2))), pair(z0, z1), x1, tail(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(tail(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(0, a__tail(mark(x2))), 0, x1, tail(x2)), A__SPLITAT(mark(0), mark(tail(x2))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(nil, a__tail(mark(x2))), nil, x1, tail(x2)), A__SPLITAT(mark(nil), mark(tail(x2))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))))

----------------------------------------

(150)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(mark(x0), head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__natsFrom(mark(z0)))), x0, x1, head(natsFrom(z0))), A__SPLITAT(mark(x0), mark(head(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__fst(mark(z0)))), x0, x1, head(fst(z0))), A__SPLITAT(mark(x0), mark(head(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__snd(mark(z0)))), x0, x1, head(snd(z0))), A__SPLITAT(mark(x0), mark(head(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__splitAt(mark(z0), mark(z1)))), x0, x1, head(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(head(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__u(mark(z0), z1, z2, z3))), x0, x1, head(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(head(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__head(mark(z0)))), x0, x1, head(head(z0))), A__SPLITAT(mark(x0), mark(head(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__tail(mark(z0)))), x0, x1, head(tail(z0))), A__SPLITAT(mark(x0), mark(head(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__sel(mark(z0), mark(z1)))), x0, x1, head(sel(z0, z1))), A__SPLITAT(mark(x0), mark(head(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(z0), mark(z1)))), x0, x1, head(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(head(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__take(mark(z0), mark(z1)))), x0, x1, head(take(z0, z1))), A__SPLITAT(mark(x0), mark(head(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(cons(mark(z0), z1))), x0, x1, head(cons(z0, z1))), A__SPLITAT(mark(x0), mark(head(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(s(mark(z0)))), x0, x1, head(s(z0))), A__SPLITAT(mark(x0), mark(head(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(pair(mark(z0), mark(z1)))), x0, x1, head(pair(z0, z1))), A__SPLITAT(mark(x0), mark(head(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(0))) -> c7(A__U(a__splitAt(mark(x0), a__head(0)), x0, x1, head(0)), A__SPLITAT(mark(x0), mark(head(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(nil))) -> c7(A__U(a__splitAt(mark(x0), a__head(nil)), x0, x1, head(nil)), A__SPLITAT(mark(x0), mark(head(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__head(mark(x2))), natsFrom(z0), x1, head(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(head(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__head(mark(x2))), fst(z0), x1, head(x2)), A__SPLITAT(mark(fst(z0)), mark(head(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__head(mark(x2))), snd(z0), x1, head(x2)), A__SPLITAT(mark(snd(z0)), mark(head(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__head(mark(x2))), splitAt(z0, z1), x1, head(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(head(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__head(mark(x2))), u(z0, z1, z2, z3), x1, head(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(head(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__head(mark(x2))), head(z0), x1, head(x2)), A__SPLITAT(mark(head(z0)), mark(head(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__head(mark(x2))), tail(z0), x1, head(x2)), A__SPLITAT(mark(tail(z0)), mark(head(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__head(mark(x2))), sel(z0, z1), x1, head(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(head(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__head(mark(x2))), afterNth(z0, z1), x1, head(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(head(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__head(mark(x2))), take(z0, z1), x1, head(x2)), A__SPLITAT(mark(take(z0, z1)), mark(head(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__head(mark(x2))), cons(z0, z1), x1, head(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(head(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__head(mark(x2))), s(z0), x1, head(x2)), A__SPLITAT(mark(s(z0)), mark(head(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__head(mark(x2))), pair(z0, z1), x1, head(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(head(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(0, a__head(mark(x2))), 0, x1, head(x2)), A__SPLITAT(mark(0), mark(head(x2))))
   A__SPLITAT(s(nil), cons(x1, head(x2))) -> c7(A__U(a__splitAt(nil, a__head(mark(x2))), nil, x1, head(x2)), A__SPLITAT(mark(nil), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__U(splitAt(mark(x0), a__tail(mark(x2))), x0, x1, tail(x2)), A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(mark(x0), tail(mark(x2))), x0, x1, tail(x2)), A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__natsFrom(mark(z0)))), x0, x1, tail(natsFrom(z0))), A__SPLITAT(mark(x0), mark(tail(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__fst(mark(z0)))), x0, x1, tail(fst(z0))), A__SPLITAT(mark(x0), mark(tail(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__snd(mark(z0)))), x0, x1, tail(snd(z0))), A__SPLITAT(mark(x0), mark(tail(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__splitAt(mark(z0), mark(z1)))), x0, x1, tail(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(tail(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__u(mark(z0), z1, z2, z3))), x0, x1, tail(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(tail(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__head(mark(z0)))), x0, x1, tail(head(z0))), A__SPLITAT(mark(x0), mark(tail(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__tail(mark(z0)))), x0, x1, tail(tail(z0))), A__SPLITAT(mark(x0), mark(tail(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__sel(mark(z0), mark(z1)))), x0, x1, tail(sel(z0, z1))), A__SPLITAT(mark(x0), mark(tail(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__afterNth(mark(z0), mark(z1)))), x0, x1, tail(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(tail(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__take(mark(z0), mark(z1)))), x0, x1, tail(take(z0, z1))), A__SPLITAT(mark(x0), mark(tail(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(cons(mark(z0), z1))), x0, x1, tail(cons(z0, z1))), A__SPLITAT(mark(x0), mark(tail(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(s(mark(z0)))), x0, x1, tail(s(z0))), A__SPLITAT(mark(x0), mark(tail(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(pair(mark(z0), mark(z1)))), x0, x1, tail(pair(z0, z1))), A__SPLITAT(mark(x0), mark(tail(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(0)), x0, x1, tail(0)), A__SPLITAT(mark(x0), mark(tail(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(nil))) -> c7(A__U(a__splitAt(mark(x0), a__tail(nil)), x0, x1, tail(nil)), A__SPLITAT(mark(x0), mark(tail(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__tail(mark(x2))), natsFrom(z0), x1, tail(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(tail(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__tail(mark(x2))), fst(z0), x1, tail(x2)), A__SPLITAT(mark(fst(z0)), mark(tail(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__tail(mark(x2))), snd(z0), x1, tail(x2)), A__SPLITAT(mark(snd(z0)), mark(tail(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__tail(mark(x2))), splitAt(z0, z1), x1, tail(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(tail(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__tail(mark(x2))), u(z0, z1, z2, z3), x1, tail(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(tail(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__tail(mark(x2))), head(z0), x1, tail(x2)), A__SPLITAT(mark(head(z0)), mark(tail(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__tail(mark(x2))), tail(z0), x1, tail(x2)), A__SPLITAT(mark(tail(z0)), mark(tail(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__tail(mark(x2))), sel(z0, z1), x1, tail(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(tail(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__tail(mark(x2))), afterNth(z0, z1), x1, tail(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(tail(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__tail(mark(x2))), take(z0, z1), x1, tail(x2)), A__SPLITAT(mark(take(z0, z1)), mark(tail(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__tail(mark(x2))), cons(z0, z1), x1, tail(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(tail(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__tail(mark(x2))), s(z0), x1, tail(x2)), A__SPLITAT(mark(s(z0)), mark(tail(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__tail(mark(x2))), pair(z0, z1), x1, tail(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(tail(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(0, a__tail(mark(x2))), 0, x1, tail(x2)), A__SPLITAT(mark(0), mark(tail(x2))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(nil, a__tail(mark(x2))), nil, x1, tail(x2)), A__SPLITAT(mark(nil), mark(tail(x2))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(mark(x0), head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__natsFrom(mark(z0)))), x0, x1, head(natsFrom(z0))), A__SPLITAT(mark(x0), mark(head(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__fst(mark(z0)))), x0, x1, head(fst(z0))), A__SPLITAT(mark(x0), mark(head(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__snd(mark(z0)))), x0, x1, head(snd(z0))), A__SPLITAT(mark(x0), mark(head(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__splitAt(mark(z0), mark(z1)))), x0, x1, head(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(head(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__u(mark(z0), z1, z2, z3))), x0, x1, head(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(head(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__head(mark(z0)))), x0, x1, head(head(z0))), A__SPLITAT(mark(x0), mark(head(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__tail(mark(z0)))), x0, x1, head(tail(z0))), A__SPLITAT(mark(x0), mark(head(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__sel(mark(z0), mark(z1)))), x0, x1, head(sel(z0, z1))), A__SPLITAT(mark(x0), mark(head(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(z0), mark(z1)))), x0, x1, head(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(head(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__take(mark(z0), mark(z1)))), x0, x1, head(take(z0, z1))), A__SPLITAT(mark(x0), mark(head(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(cons(mark(z0), z1))), x0, x1, head(cons(z0, z1))), A__SPLITAT(mark(x0), mark(head(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(s(mark(z0)))), x0, x1, head(s(z0))), A__SPLITAT(mark(x0), mark(head(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(pair(mark(z0), mark(z1)))), x0, x1, head(pair(z0, z1))), A__SPLITAT(mark(x0), mark(head(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(0))) -> c7(A__U(a__splitAt(mark(x0), a__head(0)), x0, x1, head(0)), A__SPLITAT(mark(x0), mark(head(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(nil))) -> c7(A__U(a__splitAt(mark(x0), a__head(nil)), x0, x1, head(nil)), A__SPLITAT(mark(x0), mark(head(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__head(mark(x2))), natsFrom(z0), x1, head(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(head(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__head(mark(x2))), fst(z0), x1, head(x2)), A__SPLITAT(mark(fst(z0)), mark(head(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__head(mark(x2))), snd(z0), x1, head(x2)), A__SPLITAT(mark(snd(z0)), mark(head(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__head(mark(x2))), splitAt(z0, z1), x1, head(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(head(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__head(mark(x2))), u(z0, z1, z2, z3), x1, head(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(head(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__head(mark(x2))), head(z0), x1, head(x2)), A__SPLITAT(mark(head(z0)), mark(head(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__head(mark(x2))), tail(z0), x1, head(x2)), A__SPLITAT(mark(tail(z0)), mark(head(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__head(mark(x2))), sel(z0, z1), x1, head(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(head(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__head(mark(x2))), afterNth(z0, z1), x1, head(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(head(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__head(mark(x2))), take(z0, z1), x1, head(x2)), A__SPLITAT(mark(take(z0, z1)), mark(head(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__head(mark(x2))), cons(z0, z1), x1, head(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(head(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__head(mark(x2))), s(z0), x1, head(x2)), A__SPLITAT(mark(s(z0)), mark(head(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__head(mark(x2))), pair(z0, z1), x1, head(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(head(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(0, a__head(mark(x2))), 0, x1, head(x2)), A__SPLITAT(mark(0), mark(head(x2))))
   A__SPLITAT(s(nil), cons(x1, head(x2))) -> c7(A__U(a__splitAt(nil, a__head(mark(x2))), nil, x1, head(x2)), A__SPLITAT(mark(nil), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__U(splitAt(mark(x0), a__tail(mark(x2))), x0, x1, tail(x2)), A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(mark(x0), tail(mark(x2))), x0, x1, tail(x2)), A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__natsFrom(mark(z0)))), x0, x1, tail(natsFrom(z0))), A__SPLITAT(mark(x0), mark(tail(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__fst(mark(z0)))), x0, x1, tail(fst(z0))), A__SPLITAT(mark(x0), mark(tail(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__snd(mark(z0)))), x0, x1, tail(snd(z0))), A__SPLITAT(mark(x0), mark(tail(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__splitAt(mark(z0), mark(z1)))), x0, x1, tail(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(tail(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__u(mark(z0), z1, z2, z3))), x0, x1, tail(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(tail(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__head(mark(z0)))), x0, x1, tail(head(z0))), A__SPLITAT(mark(x0), mark(tail(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__tail(mark(z0)))), x0, x1, tail(tail(z0))), A__SPLITAT(mark(x0), mark(tail(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__sel(mark(z0), mark(z1)))), x0, x1, tail(sel(z0, z1))), A__SPLITAT(mark(x0), mark(tail(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__afterNth(mark(z0), mark(z1)))), x0, x1, tail(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(tail(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__take(mark(z0), mark(z1)))), x0, x1, tail(take(z0, z1))), A__SPLITAT(mark(x0), mark(tail(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(cons(mark(z0), z1))), x0, x1, tail(cons(z0, z1))), A__SPLITAT(mark(x0), mark(tail(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(s(mark(z0)))), x0, x1, tail(s(z0))), A__SPLITAT(mark(x0), mark(tail(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(pair(mark(z0), mark(z1)))), x0, x1, tail(pair(z0, z1))), A__SPLITAT(mark(x0), mark(tail(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(0)), x0, x1, tail(0)), A__SPLITAT(mark(x0), mark(tail(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(nil))) -> c7(A__U(a__splitAt(mark(x0), a__tail(nil)), x0, x1, tail(nil)), A__SPLITAT(mark(x0), mark(tail(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__tail(mark(x2))), natsFrom(z0), x1, tail(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(tail(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__tail(mark(x2))), fst(z0), x1, tail(x2)), A__SPLITAT(mark(fst(z0)), mark(tail(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__tail(mark(x2))), snd(z0), x1, tail(x2)), A__SPLITAT(mark(snd(z0)), mark(tail(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__tail(mark(x2))), splitAt(z0, z1), x1, tail(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(tail(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__tail(mark(x2))), u(z0, z1, z2, z3), x1, tail(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(tail(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__tail(mark(x2))), head(z0), x1, tail(x2)), A__SPLITAT(mark(head(z0)), mark(tail(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__tail(mark(x2))), tail(z0), x1, tail(x2)), A__SPLITAT(mark(tail(z0)), mark(tail(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__tail(mark(x2))), sel(z0, z1), x1, tail(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(tail(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__tail(mark(x2))), afterNth(z0, z1), x1, tail(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(tail(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__tail(mark(x2))), take(z0, z1), x1, tail(x2)), A__SPLITAT(mark(take(z0, z1)), mark(tail(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__tail(mark(x2))), cons(z0, z1), x1, tail(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(tail(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__tail(mark(x2))), s(z0), x1, tail(x2)), A__SPLITAT(mark(s(z0)), mark(tail(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__tail(mark(x2))), pair(z0, z1), x1, tail(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(tail(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(0, a__tail(mark(x2))), 0, x1, tail(x2)), A__SPLITAT(mark(0), mark(tail(x2))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(nil, a__tail(mark(x2))), nil, x1, tail(x2)), A__SPLITAT(mark(nil), mark(tail(x2))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1, c33_2, c33_1, c7_1


----------------------------------------

(151) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 3 trailing tuple parts
----------------------------------------

(152)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(mark(x0), head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__natsFrom(mark(z0)))), x0, x1, head(natsFrom(z0))), A__SPLITAT(mark(x0), mark(head(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__fst(mark(z0)))), x0, x1, head(fst(z0))), A__SPLITAT(mark(x0), mark(head(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__snd(mark(z0)))), x0, x1, head(snd(z0))), A__SPLITAT(mark(x0), mark(head(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__splitAt(mark(z0), mark(z1)))), x0, x1, head(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(head(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__u(mark(z0), z1, z2, z3))), x0, x1, head(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(head(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__head(mark(z0)))), x0, x1, head(head(z0))), A__SPLITAT(mark(x0), mark(head(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__tail(mark(z0)))), x0, x1, head(tail(z0))), A__SPLITAT(mark(x0), mark(head(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__sel(mark(z0), mark(z1)))), x0, x1, head(sel(z0, z1))), A__SPLITAT(mark(x0), mark(head(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(z0), mark(z1)))), x0, x1, head(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(head(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__take(mark(z0), mark(z1)))), x0, x1, head(take(z0, z1))), A__SPLITAT(mark(x0), mark(head(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(cons(mark(z0), z1))), x0, x1, head(cons(z0, z1))), A__SPLITAT(mark(x0), mark(head(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(s(mark(z0)))), x0, x1, head(s(z0))), A__SPLITAT(mark(x0), mark(head(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(pair(mark(z0), mark(z1)))), x0, x1, head(pair(z0, z1))), A__SPLITAT(mark(x0), mark(head(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(0))) -> c7(A__U(a__splitAt(mark(x0), a__head(0)), x0, x1, head(0)), A__SPLITAT(mark(x0), mark(head(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(nil))) -> c7(A__U(a__splitAt(mark(x0), a__head(nil)), x0, x1, head(nil)), A__SPLITAT(mark(x0), mark(head(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__head(mark(x2))), natsFrom(z0), x1, head(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(head(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__head(mark(x2))), fst(z0), x1, head(x2)), A__SPLITAT(mark(fst(z0)), mark(head(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__head(mark(x2))), snd(z0), x1, head(x2)), A__SPLITAT(mark(snd(z0)), mark(head(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__head(mark(x2))), splitAt(z0, z1), x1, head(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(head(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__head(mark(x2))), u(z0, z1, z2, z3), x1, head(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(head(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__head(mark(x2))), head(z0), x1, head(x2)), A__SPLITAT(mark(head(z0)), mark(head(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__head(mark(x2))), tail(z0), x1, head(x2)), A__SPLITAT(mark(tail(z0)), mark(head(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__head(mark(x2))), sel(z0, z1), x1, head(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(head(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__head(mark(x2))), afterNth(z0, z1), x1, head(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(head(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__head(mark(x2))), take(z0, z1), x1, head(x2)), A__SPLITAT(mark(take(z0, z1)), mark(head(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__head(mark(x2))), cons(z0, z1), x1, head(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(head(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__head(mark(x2))), s(z0), x1, head(x2)), A__SPLITAT(mark(s(z0)), mark(head(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__head(mark(x2))), pair(z0, z1), x1, head(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(head(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(0, a__head(mark(x2))), 0, x1, head(x2)), A__SPLITAT(mark(0), mark(head(x2))))
   A__SPLITAT(s(nil), cons(x1, head(x2))) -> c7(A__U(a__splitAt(nil, a__head(mark(x2))), nil, x1, head(x2)), A__SPLITAT(mark(nil), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(mark(x0), tail(mark(x2))), x0, x1, tail(x2)), A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__natsFrom(mark(z0)))), x0, x1, tail(natsFrom(z0))), A__SPLITAT(mark(x0), mark(tail(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__fst(mark(z0)))), x0, x1, tail(fst(z0))), A__SPLITAT(mark(x0), mark(tail(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__snd(mark(z0)))), x0, x1, tail(snd(z0))), A__SPLITAT(mark(x0), mark(tail(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__splitAt(mark(z0), mark(z1)))), x0, x1, tail(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(tail(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__u(mark(z0), z1, z2, z3))), x0, x1, tail(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(tail(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__head(mark(z0)))), x0, x1, tail(head(z0))), A__SPLITAT(mark(x0), mark(tail(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__tail(mark(z0)))), x0, x1, tail(tail(z0))), A__SPLITAT(mark(x0), mark(tail(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__sel(mark(z0), mark(z1)))), x0, x1, tail(sel(z0, z1))), A__SPLITAT(mark(x0), mark(tail(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__afterNth(mark(z0), mark(z1)))), x0, x1, tail(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(tail(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__take(mark(z0), mark(z1)))), x0, x1, tail(take(z0, z1))), A__SPLITAT(mark(x0), mark(tail(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(cons(mark(z0), z1))), x0, x1, tail(cons(z0, z1))), A__SPLITAT(mark(x0), mark(tail(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(s(mark(z0)))), x0, x1, tail(s(z0))), A__SPLITAT(mark(x0), mark(tail(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(pair(mark(z0), mark(z1)))), x0, x1, tail(pair(z0, z1))), A__SPLITAT(mark(x0), mark(tail(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(0)), x0, x1, tail(0)), A__SPLITAT(mark(x0), mark(tail(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(nil))) -> c7(A__U(a__splitAt(mark(x0), a__tail(nil)), x0, x1, tail(nil)), A__SPLITAT(mark(x0), mark(tail(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__tail(mark(x2))), natsFrom(z0), x1, tail(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(tail(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__tail(mark(x2))), fst(z0), x1, tail(x2)), A__SPLITAT(mark(fst(z0)), mark(tail(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__tail(mark(x2))), snd(z0), x1, tail(x2)), A__SPLITAT(mark(snd(z0)), mark(tail(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__tail(mark(x2))), splitAt(z0, z1), x1, tail(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(tail(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__tail(mark(x2))), u(z0, z1, z2, z3), x1, tail(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(tail(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__tail(mark(x2))), head(z0), x1, tail(x2)), A__SPLITAT(mark(head(z0)), mark(tail(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__tail(mark(x2))), tail(z0), x1, tail(x2)), A__SPLITAT(mark(tail(z0)), mark(tail(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__tail(mark(x2))), sel(z0, z1), x1, tail(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(tail(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__tail(mark(x2))), afterNth(z0, z1), x1, tail(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(tail(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__tail(mark(x2))), take(z0, z1), x1, tail(x2)), A__SPLITAT(mark(take(z0, z1)), mark(tail(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__tail(mark(x2))), cons(z0, z1), x1, tail(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(tail(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__tail(mark(x2))), s(z0), x1, tail(x2)), A__SPLITAT(mark(s(z0)), mark(tail(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__tail(mark(x2))), pair(z0, z1), x1, tail(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(tail(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(0, a__tail(mark(x2))), 0, x1, tail(x2)), A__SPLITAT(mark(0), mark(tail(x2))))
   A__SPLITAT(s(nil), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(nil, a__tail(mark(x2))), nil, x1, tail(x2)), A__SPLITAT(mark(nil), mark(tail(x2))))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(mark(x0), head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__natsFrom(mark(z0)))), x0, x1, head(natsFrom(z0))), A__SPLITAT(mark(x0), mark(head(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__fst(mark(z0)))), x0, x1, head(fst(z0))), A__SPLITAT(mark(x0), mark(head(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__snd(mark(z0)))), x0, x1, head(snd(z0))), A__SPLITAT(mark(x0), mark(head(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__splitAt(mark(z0), mark(z1)))), x0, x1, head(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(head(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__u(mark(z0), z1, z2, z3))), x0, x1, head(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(head(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__head(mark(z0)))), x0, x1, head(head(z0))), A__SPLITAT(mark(x0), mark(head(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__tail(mark(z0)))), x0, x1, head(tail(z0))), A__SPLITAT(mark(x0), mark(head(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__sel(mark(z0), mark(z1)))), x0, x1, head(sel(z0, z1))), A__SPLITAT(mark(x0), mark(head(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(z0), mark(z1)))), x0, x1, head(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(head(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__take(mark(z0), mark(z1)))), x0, x1, head(take(z0, z1))), A__SPLITAT(mark(x0), mark(head(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(cons(mark(z0), z1))), x0, x1, head(cons(z0, z1))), A__SPLITAT(mark(x0), mark(head(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(s(mark(z0)))), x0, x1, head(s(z0))), A__SPLITAT(mark(x0), mark(head(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(pair(mark(z0), mark(z1)))), x0, x1, head(pair(z0, z1))), A__SPLITAT(mark(x0), mark(head(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(0))) -> c7(A__U(a__splitAt(mark(x0), a__head(0)), x0, x1, head(0)), A__SPLITAT(mark(x0), mark(head(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(nil))) -> c7(A__U(a__splitAt(mark(x0), a__head(nil)), x0, x1, head(nil)), A__SPLITAT(mark(x0), mark(head(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__head(mark(x2))), natsFrom(z0), x1, head(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(head(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__head(mark(x2))), fst(z0), x1, head(x2)), A__SPLITAT(mark(fst(z0)), mark(head(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__head(mark(x2))), snd(z0), x1, head(x2)), A__SPLITAT(mark(snd(z0)), mark(head(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__head(mark(x2))), splitAt(z0, z1), x1, head(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(head(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__head(mark(x2))), u(z0, z1, z2, z3), x1, head(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(head(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__head(mark(x2))), head(z0), x1, head(x2)), A__SPLITAT(mark(head(z0)), mark(head(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__head(mark(x2))), tail(z0), x1, head(x2)), A__SPLITAT(mark(tail(z0)), mark(head(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__head(mark(x2))), sel(z0, z1), x1, head(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(head(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__head(mark(x2))), afterNth(z0, z1), x1, head(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(head(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__head(mark(x2))), take(z0, z1), x1, head(x2)), A__SPLITAT(mark(take(z0, z1)), mark(head(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__head(mark(x2))), cons(z0, z1), x1, head(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(head(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__head(mark(x2))), s(z0), x1, head(x2)), A__SPLITAT(mark(s(z0)), mark(head(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__head(mark(x2))), pair(z0, z1), x1, head(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(head(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(0, a__head(mark(x2))), 0, x1, head(x2)), A__SPLITAT(mark(0), mark(head(x2))))
   A__SPLITAT(s(nil), cons(x1, head(x2))) -> c7(A__U(a__splitAt(nil, a__head(mark(x2))), nil, x1, head(x2)), A__SPLITAT(mark(nil), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(mark(x0), tail(mark(x2))), x0, x1, tail(x2)), A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__natsFrom(mark(z0)))), x0, x1, tail(natsFrom(z0))), A__SPLITAT(mark(x0), mark(tail(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__fst(mark(z0)))), x0, x1, tail(fst(z0))), A__SPLITAT(mark(x0), mark(tail(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__snd(mark(z0)))), x0, x1, tail(snd(z0))), A__SPLITAT(mark(x0), mark(tail(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__splitAt(mark(z0), mark(z1)))), x0, x1, tail(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(tail(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__u(mark(z0), z1, z2, z3))), x0, x1, tail(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(tail(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__head(mark(z0)))), x0, x1, tail(head(z0))), A__SPLITAT(mark(x0), mark(tail(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__tail(mark(z0)))), x0, x1, tail(tail(z0))), A__SPLITAT(mark(x0), mark(tail(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__sel(mark(z0), mark(z1)))), x0, x1, tail(sel(z0, z1))), A__SPLITAT(mark(x0), mark(tail(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__afterNth(mark(z0), mark(z1)))), x0, x1, tail(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(tail(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__take(mark(z0), mark(z1)))), x0, x1, tail(take(z0, z1))), A__SPLITAT(mark(x0), mark(tail(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(cons(mark(z0), z1))), x0, x1, tail(cons(z0, z1))), A__SPLITAT(mark(x0), mark(tail(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(s(mark(z0)))), x0, x1, tail(s(z0))), A__SPLITAT(mark(x0), mark(tail(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(pair(mark(z0), mark(z1)))), x0, x1, tail(pair(z0, z1))), A__SPLITAT(mark(x0), mark(tail(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(0)), x0, x1, tail(0)), A__SPLITAT(mark(x0), mark(tail(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(nil))) -> c7(A__U(a__splitAt(mark(x0), a__tail(nil)), x0, x1, tail(nil)), A__SPLITAT(mark(x0), mark(tail(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__tail(mark(x2))), natsFrom(z0), x1, tail(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(tail(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__tail(mark(x2))), fst(z0), x1, tail(x2)), A__SPLITAT(mark(fst(z0)), mark(tail(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__tail(mark(x2))), snd(z0), x1, tail(x2)), A__SPLITAT(mark(snd(z0)), mark(tail(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__tail(mark(x2))), splitAt(z0, z1), x1, tail(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(tail(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__tail(mark(x2))), u(z0, z1, z2, z3), x1, tail(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(tail(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__tail(mark(x2))), head(z0), x1, tail(x2)), A__SPLITAT(mark(head(z0)), mark(tail(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__tail(mark(x2))), tail(z0), x1, tail(x2)), A__SPLITAT(mark(tail(z0)), mark(tail(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__tail(mark(x2))), sel(z0, z1), x1, tail(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(tail(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__tail(mark(x2))), afterNth(z0, z1), x1, tail(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(tail(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__tail(mark(x2))), take(z0, z1), x1, tail(x2)), A__SPLITAT(mark(take(z0, z1)), mark(tail(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__tail(mark(x2))), cons(z0, z1), x1, tail(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(tail(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__tail(mark(x2))), s(z0), x1, tail(x2)), A__SPLITAT(mark(s(z0)), mark(tail(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__tail(mark(x2))), pair(z0, z1), x1, tail(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(tail(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(0, a__tail(mark(x2))), 0, x1, tail(x2)), A__SPLITAT(mark(0), mark(tail(x2))))
   A__SPLITAT(s(nil), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(nil, a__tail(mark(x2))), nil, x1, tail(x2)), A__SPLITAT(mark(nil), mark(tail(x2))))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1, c33_2, c33_1, c7_1


----------------------------------------

(153) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0)) by 
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(splitAt(mark(x0), a__sel(mark(x2), mark(x3))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(mark(x2)), mark(mark(x3))))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), sel(mark(x2), mark(x3))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__natsFrom(mark(z0)))), x0, x1, sel(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(sel(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__fst(mark(z0)))), x0, x1, sel(x2, fst(z0))), A__SPLITAT(mark(x0), mark(sel(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__snd(mark(z0)))), x0, x1, sel(x2, snd(z0))), A__SPLITAT(mark(x0), mark(sel(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, sel(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, sel(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(sel(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__head(mark(z0)))), x0, x1, sel(x2, head(z0))), A__SPLITAT(mark(x0), mark(sel(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__tail(mark(z0)))), x0, x1, sel(x2, tail(z0))), A__SPLITAT(mark(x0), mark(sel(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, sel(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, sel(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, sel(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), cons(mark(z0), z1))), x0, x1, sel(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), s(mark(z0)))), x0, x1, sel(x2, s(z0))), A__SPLITAT(mark(x0), mark(sel(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, sel(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), 0)), x0, x1, sel(x2, 0)), A__SPLITAT(mark(x0), mark(sel(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), nil)), x0, x1, sel(x2, nil)), A__SPLITAT(mark(x0), mark(sel(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__natsFrom(mark(z0)), mark(x3))), x0, x1, sel(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(sel(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__fst(mark(z0)), mark(x3))), x0, x1, sel(fst(z0), x3)), A__SPLITAT(mark(x0), mark(sel(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__snd(mark(z0)), mark(x3))), x0, x1, sel(snd(z0), x3)), A__SPLITAT(mark(x0), mark(sel(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, sel(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(sel(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__head(mark(z0)), mark(x3))), x0, x1, sel(head(z0), x3)), A__SPLITAT(mark(x0), mark(sel(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__tail(mark(z0)), mark(x3))), x0, x1, sel(tail(z0), x3)), A__SPLITAT(mark(x0), mark(sel(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(cons(mark(z0), z1), mark(x3))), x0, x1, sel(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(s(mark(z0)), mark(x3))), x0, x1, sel(s(z0), x3)), A__SPLITAT(mark(x0), mark(sel(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(0, mark(x3))), x0, x1, sel(0, x3)), A__SPLITAT(mark(x0), mark(sel(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(nil, mark(x3))), x0, x1, sel(nil, x3)), A__SPLITAT(mark(x0), mark(sel(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__sel(mark(x2), mark(x3))), natsFrom(z0), x1, sel(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(sel(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__sel(mark(x2), mark(x3))), fst(z0), x1, sel(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(sel(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__sel(mark(x2), mark(x3))), snd(z0), x1, sel(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(sel(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), splitAt(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(sel(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__sel(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, sel(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(sel(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__sel(mark(x2), mark(x3))), head(z0), x1, sel(x2, x3)), A__SPLITAT(mark(head(z0)), mark(sel(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__sel(mark(x2), mark(x3))), tail(z0), x1, sel(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(sel(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), sel(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(sel(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), afterNth(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(sel(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), take(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(sel(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__sel(mark(x2), mark(x3))), cons(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(sel(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__sel(mark(x2), mark(x3))), s(z0), x1, sel(x2, x3)), A__SPLITAT(mark(s(z0)), mark(sel(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), pair(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(sel(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(0, a__sel(mark(x2), mark(x3))), 0, x1, sel(x2, x3)), A__SPLITAT(mark(0), mark(sel(x2, x3))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(nil, a__sel(mark(x2), mark(x3))), nil, x1, sel(x2, x3)), A__SPLITAT(mark(nil), mark(sel(x2, x3))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))))

----------------------------------------

(154)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(mark(x0), head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__natsFrom(mark(z0)))), x0, x1, head(natsFrom(z0))), A__SPLITAT(mark(x0), mark(head(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__fst(mark(z0)))), x0, x1, head(fst(z0))), A__SPLITAT(mark(x0), mark(head(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__snd(mark(z0)))), x0, x1, head(snd(z0))), A__SPLITAT(mark(x0), mark(head(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__splitAt(mark(z0), mark(z1)))), x0, x1, head(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(head(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__u(mark(z0), z1, z2, z3))), x0, x1, head(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(head(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__head(mark(z0)))), x0, x1, head(head(z0))), A__SPLITAT(mark(x0), mark(head(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__tail(mark(z0)))), x0, x1, head(tail(z0))), A__SPLITAT(mark(x0), mark(head(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__sel(mark(z0), mark(z1)))), x0, x1, head(sel(z0, z1))), A__SPLITAT(mark(x0), mark(head(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(z0), mark(z1)))), x0, x1, head(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(head(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__take(mark(z0), mark(z1)))), x0, x1, head(take(z0, z1))), A__SPLITAT(mark(x0), mark(head(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(cons(mark(z0), z1))), x0, x1, head(cons(z0, z1))), A__SPLITAT(mark(x0), mark(head(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(s(mark(z0)))), x0, x1, head(s(z0))), A__SPLITAT(mark(x0), mark(head(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(pair(mark(z0), mark(z1)))), x0, x1, head(pair(z0, z1))), A__SPLITAT(mark(x0), mark(head(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(0))) -> c7(A__U(a__splitAt(mark(x0), a__head(0)), x0, x1, head(0)), A__SPLITAT(mark(x0), mark(head(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(nil))) -> c7(A__U(a__splitAt(mark(x0), a__head(nil)), x0, x1, head(nil)), A__SPLITAT(mark(x0), mark(head(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__head(mark(x2))), natsFrom(z0), x1, head(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(head(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__head(mark(x2))), fst(z0), x1, head(x2)), A__SPLITAT(mark(fst(z0)), mark(head(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__head(mark(x2))), snd(z0), x1, head(x2)), A__SPLITAT(mark(snd(z0)), mark(head(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__head(mark(x2))), splitAt(z0, z1), x1, head(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(head(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__head(mark(x2))), u(z0, z1, z2, z3), x1, head(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(head(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__head(mark(x2))), head(z0), x1, head(x2)), A__SPLITAT(mark(head(z0)), mark(head(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__head(mark(x2))), tail(z0), x1, head(x2)), A__SPLITAT(mark(tail(z0)), mark(head(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__head(mark(x2))), sel(z0, z1), x1, head(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(head(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__head(mark(x2))), afterNth(z0, z1), x1, head(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(head(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__head(mark(x2))), take(z0, z1), x1, head(x2)), A__SPLITAT(mark(take(z0, z1)), mark(head(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__head(mark(x2))), cons(z0, z1), x1, head(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(head(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__head(mark(x2))), s(z0), x1, head(x2)), A__SPLITAT(mark(s(z0)), mark(head(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__head(mark(x2))), pair(z0, z1), x1, head(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(head(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(0, a__head(mark(x2))), 0, x1, head(x2)), A__SPLITAT(mark(0), mark(head(x2))))
   A__SPLITAT(s(nil), cons(x1, head(x2))) -> c7(A__U(a__splitAt(nil, a__head(mark(x2))), nil, x1, head(x2)), A__SPLITAT(mark(nil), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(mark(x0), tail(mark(x2))), x0, x1, tail(x2)), A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__natsFrom(mark(z0)))), x0, x1, tail(natsFrom(z0))), A__SPLITAT(mark(x0), mark(tail(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__fst(mark(z0)))), x0, x1, tail(fst(z0))), A__SPLITAT(mark(x0), mark(tail(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__snd(mark(z0)))), x0, x1, tail(snd(z0))), A__SPLITAT(mark(x0), mark(tail(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__splitAt(mark(z0), mark(z1)))), x0, x1, tail(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(tail(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__u(mark(z0), z1, z2, z3))), x0, x1, tail(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(tail(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__head(mark(z0)))), x0, x1, tail(head(z0))), A__SPLITAT(mark(x0), mark(tail(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__tail(mark(z0)))), x0, x1, tail(tail(z0))), A__SPLITAT(mark(x0), mark(tail(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__sel(mark(z0), mark(z1)))), x0, x1, tail(sel(z0, z1))), A__SPLITAT(mark(x0), mark(tail(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__afterNth(mark(z0), mark(z1)))), x0, x1, tail(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(tail(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__take(mark(z0), mark(z1)))), x0, x1, tail(take(z0, z1))), A__SPLITAT(mark(x0), mark(tail(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(cons(mark(z0), z1))), x0, x1, tail(cons(z0, z1))), A__SPLITAT(mark(x0), mark(tail(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(s(mark(z0)))), x0, x1, tail(s(z0))), A__SPLITAT(mark(x0), mark(tail(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(pair(mark(z0), mark(z1)))), x0, x1, tail(pair(z0, z1))), A__SPLITAT(mark(x0), mark(tail(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(0)), x0, x1, tail(0)), A__SPLITAT(mark(x0), mark(tail(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(nil))) -> c7(A__U(a__splitAt(mark(x0), a__tail(nil)), x0, x1, tail(nil)), A__SPLITAT(mark(x0), mark(tail(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__tail(mark(x2))), natsFrom(z0), x1, tail(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(tail(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__tail(mark(x2))), fst(z0), x1, tail(x2)), A__SPLITAT(mark(fst(z0)), mark(tail(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__tail(mark(x2))), snd(z0), x1, tail(x2)), A__SPLITAT(mark(snd(z0)), mark(tail(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__tail(mark(x2))), splitAt(z0, z1), x1, tail(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(tail(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__tail(mark(x2))), u(z0, z1, z2, z3), x1, tail(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(tail(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__tail(mark(x2))), head(z0), x1, tail(x2)), A__SPLITAT(mark(head(z0)), mark(tail(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__tail(mark(x2))), tail(z0), x1, tail(x2)), A__SPLITAT(mark(tail(z0)), mark(tail(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__tail(mark(x2))), sel(z0, z1), x1, tail(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(tail(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__tail(mark(x2))), afterNth(z0, z1), x1, tail(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(tail(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__tail(mark(x2))), take(z0, z1), x1, tail(x2)), A__SPLITAT(mark(take(z0, z1)), mark(tail(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__tail(mark(x2))), cons(z0, z1), x1, tail(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(tail(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__tail(mark(x2))), s(z0), x1, tail(x2)), A__SPLITAT(mark(s(z0)), mark(tail(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__tail(mark(x2))), pair(z0, z1), x1, tail(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(tail(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(0, a__tail(mark(x2))), 0, x1, tail(x2)), A__SPLITAT(mark(0), mark(tail(x2))))
   A__SPLITAT(s(nil), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(nil, a__tail(mark(x2))), nil, x1, tail(x2)), A__SPLITAT(mark(nil), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(splitAt(mark(x0), a__sel(mark(x2), mark(x3))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(mark(x2)), mark(mark(x3))))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), sel(mark(x2), mark(x3))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__natsFrom(mark(z0)))), x0, x1, sel(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(sel(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__fst(mark(z0)))), x0, x1, sel(x2, fst(z0))), A__SPLITAT(mark(x0), mark(sel(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__snd(mark(z0)))), x0, x1, sel(x2, snd(z0))), A__SPLITAT(mark(x0), mark(sel(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, sel(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, sel(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(sel(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__head(mark(z0)))), x0, x1, sel(x2, head(z0))), A__SPLITAT(mark(x0), mark(sel(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__tail(mark(z0)))), x0, x1, sel(x2, tail(z0))), A__SPLITAT(mark(x0), mark(sel(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, sel(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, sel(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, sel(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), cons(mark(z0), z1))), x0, x1, sel(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), s(mark(z0)))), x0, x1, sel(x2, s(z0))), A__SPLITAT(mark(x0), mark(sel(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, sel(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), 0)), x0, x1, sel(x2, 0)), A__SPLITAT(mark(x0), mark(sel(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), nil)), x0, x1, sel(x2, nil)), A__SPLITAT(mark(x0), mark(sel(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__natsFrom(mark(z0)), mark(x3))), x0, x1, sel(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(sel(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__fst(mark(z0)), mark(x3))), x0, x1, sel(fst(z0), x3)), A__SPLITAT(mark(x0), mark(sel(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__snd(mark(z0)), mark(x3))), x0, x1, sel(snd(z0), x3)), A__SPLITAT(mark(x0), mark(sel(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, sel(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(sel(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__head(mark(z0)), mark(x3))), x0, x1, sel(head(z0), x3)), A__SPLITAT(mark(x0), mark(sel(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__tail(mark(z0)), mark(x3))), x0, x1, sel(tail(z0), x3)), A__SPLITAT(mark(x0), mark(sel(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(cons(mark(z0), z1), mark(x3))), x0, x1, sel(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(s(mark(z0)), mark(x3))), x0, x1, sel(s(z0), x3)), A__SPLITAT(mark(x0), mark(sel(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(0, mark(x3))), x0, x1, sel(0, x3)), A__SPLITAT(mark(x0), mark(sel(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(nil, mark(x3))), x0, x1, sel(nil, x3)), A__SPLITAT(mark(x0), mark(sel(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__sel(mark(x2), mark(x3))), natsFrom(z0), x1, sel(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(sel(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__sel(mark(x2), mark(x3))), fst(z0), x1, sel(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(sel(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__sel(mark(x2), mark(x3))), snd(z0), x1, sel(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(sel(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), splitAt(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(sel(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__sel(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, sel(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(sel(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__sel(mark(x2), mark(x3))), head(z0), x1, sel(x2, x3)), A__SPLITAT(mark(head(z0)), mark(sel(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__sel(mark(x2), mark(x3))), tail(z0), x1, sel(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(sel(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), sel(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(sel(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), afterNth(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(sel(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), take(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(sel(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__sel(mark(x2), mark(x3))), cons(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(sel(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__sel(mark(x2), mark(x3))), s(z0), x1, sel(x2, x3)), A__SPLITAT(mark(s(z0)), mark(sel(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), pair(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(sel(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(0, a__sel(mark(x2), mark(x3))), 0, x1, sel(x2, x3)), A__SPLITAT(mark(0), mark(sel(x2, x3))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(nil, a__sel(mark(x2), mark(x3))), nil, x1, sel(x2, x3)), A__SPLITAT(mark(nil), mark(sel(x2, x3))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(mark(x0), head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__natsFrom(mark(z0)))), x0, x1, head(natsFrom(z0))), A__SPLITAT(mark(x0), mark(head(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__fst(mark(z0)))), x0, x1, head(fst(z0))), A__SPLITAT(mark(x0), mark(head(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__snd(mark(z0)))), x0, x1, head(snd(z0))), A__SPLITAT(mark(x0), mark(head(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__splitAt(mark(z0), mark(z1)))), x0, x1, head(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(head(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__u(mark(z0), z1, z2, z3))), x0, x1, head(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(head(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__head(mark(z0)))), x0, x1, head(head(z0))), A__SPLITAT(mark(x0), mark(head(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__tail(mark(z0)))), x0, x1, head(tail(z0))), A__SPLITAT(mark(x0), mark(head(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__sel(mark(z0), mark(z1)))), x0, x1, head(sel(z0, z1))), A__SPLITAT(mark(x0), mark(head(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(z0), mark(z1)))), x0, x1, head(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(head(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__take(mark(z0), mark(z1)))), x0, x1, head(take(z0, z1))), A__SPLITAT(mark(x0), mark(head(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(cons(mark(z0), z1))), x0, x1, head(cons(z0, z1))), A__SPLITAT(mark(x0), mark(head(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(s(mark(z0)))), x0, x1, head(s(z0))), A__SPLITAT(mark(x0), mark(head(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(pair(mark(z0), mark(z1)))), x0, x1, head(pair(z0, z1))), A__SPLITAT(mark(x0), mark(head(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(0))) -> c7(A__U(a__splitAt(mark(x0), a__head(0)), x0, x1, head(0)), A__SPLITAT(mark(x0), mark(head(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(nil))) -> c7(A__U(a__splitAt(mark(x0), a__head(nil)), x0, x1, head(nil)), A__SPLITAT(mark(x0), mark(head(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__head(mark(x2))), natsFrom(z0), x1, head(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(head(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__head(mark(x2))), fst(z0), x1, head(x2)), A__SPLITAT(mark(fst(z0)), mark(head(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__head(mark(x2))), snd(z0), x1, head(x2)), A__SPLITAT(mark(snd(z0)), mark(head(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__head(mark(x2))), splitAt(z0, z1), x1, head(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(head(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__head(mark(x2))), u(z0, z1, z2, z3), x1, head(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(head(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__head(mark(x2))), head(z0), x1, head(x2)), A__SPLITAT(mark(head(z0)), mark(head(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__head(mark(x2))), tail(z0), x1, head(x2)), A__SPLITAT(mark(tail(z0)), mark(head(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__head(mark(x2))), sel(z0, z1), x1, head(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(head(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__head(mark(x2))), afterNth(z0, z1), x1, head(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(head(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__head(mark(x2))), take(z0, z1), x1, head(x2)), A__SPLITAT(mark(take(z0, z1)), mark(head(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__head(mark(x2))), cons(z0, z1), x1, head(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(head(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__head(mark(x2))), s(z0), x1, head(x2)), A__SPLITAT(mark(s(z0)), mark(head(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__head(mark(x2))), pair(z0, z1), x1, head(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(head(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(0, a__head(mark(x2))), 0, x1, head(x2)), A__SPLITAT(mark(0), mark(head(x2))))
   A__SPLITAT(s(nil), cons(x1, head(x2))) -> c7(A__U(a__splitAt(nil, a__head(mark(x2))), nil, x1, head(x2)), A__SPLITAT(mark(nil), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(mark(x0), tail(mark(x2))), x0, x1, tail(x2)), A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__natsFrom(mark(z0)))), x0, x1, tail(natsFrom(z0))), A__SPLITAT(mark(x0), mark(tail(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__fst(mark(z0)))), x0, x1, tail(fst(z0))), A__SPLITAT(mark(x0), mark(tail(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__snd(mark(z0)))), x0, x1, tail(snd(z0))), A__SPLITAT(mark(x0), mark(tail(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__splitAt(mark(z0), mark(z1)))), x0, x1, tail(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(tail(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__u(mark(z0), z1, z2, z3))), x0, x1, tail(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(tail(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__head(mark(z0)))), x0, x1, tail(head(z0))), A__SPLITAT(mark(x0), mark(tail(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__tail(mark(z0)))), x0, x1, tail(tail(z0))), A__SPLITAT(mark(x0), mark(tail(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__sel(mark(z0), mark(z1)))), x0, x1, tail(sel(z0, z1))), A__SPLITAT(mark(x0), mark(tail(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__afterNth(mark(z0), mark(z1)))), x0, x1, tail(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(tail(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__take(mark(z0), mark(z1)))), x0, x1, tail(take(z0, z1))), A__SPLITAT(mark(x0), mark(tail(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(cons(mark(z0), z1))), x0, x1, tail(cons(z0, z1))), A__SPLITAT(mark(x0), mark(tail(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(s(mark(z0)))), x0, x1, tail(s(z0))), A__SPLITAT(mark(x0), mark(tail(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(pair(mark(z0), mark(z1)))), x0, x1, tail(pair(z0, z1))), A__SPLITAT(mark(x0), mark(tail(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(0)), x0, x1, tail(0)), A__SPLITAT(mark(x0), mark(tail(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(nil))) -> c7(A__U(a__splitAt(mark(x0), a__tail(nil)), x0, x1, tail(nil)), A__SPLITAT(mark(x0), mark(tail(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__tail(mark(x2))), natsFrom(z0), x1, tail(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(tail(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__tail(mark(x2))), fst(z0), x1, tail(x2)), A__SPLITAT(mark(fst(z0)), mark(tail(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__tail(mark(x2))), snd(z0), x1, tail(x2)), A__SPLITAT(mark(snd(z0)), mark(tail(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__tail(mark(x2))), splitAt(z0, z1), x1, tail(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(tail(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__tail(mark(x2))), u(z0, z1, z2, z3), x1, tail(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(tail(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__tail(mark(x2))), head(z0), x1, tail(x2)), A__SPLITAT(mark(head(z0)), mark(tail(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__tail(mark(x2))), tail(z0), x1, tail(x2)), A__SPLITAT(mark(tail(z0)), mark(tail(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__tail(mark(x2))), sel(z0, z1), x1, tail(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(tail(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__tail(mark(x2))), afterNth(z0, z1), x1, tail(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(tail(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__tail(mark(x2))), take(z0, z1), x1, tail(x2)), A__SPLITAT(mark(take(z0, z1)), mark(tail(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__tail(mark(x2))), cons(z0, z1), x1, tail(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(tail(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__tail(mark(x2))), s(z0), x1, tail(x2)), A__SPLITAT(mark(s(z0)), mark(tail(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__tail(mark(x2))), pair(z0, z1), x1, tail(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(tail(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(0, a__tail(mark(x2))), 0, x1, tail(x2)), A__SPLITAT(mark(0), mark(tail(x2))))
   A__SPLITAT(s(nil), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(nil, a__tail(mark(x2))), nil, x1, tail(x2)), A__SPLITAT(mark(nil), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(splitAt(mark(x0), a__sel(mark(x2), mark(x3))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(mark(x2)), mark(mark(x3))))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), sel(mark(x2), mark(x3))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__natsFrom(mark(z0)))), x0, x1, sel(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(sel(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__fst(mark(z0)))), x0, x1, sel(x2, fst(z0))), A__SPLITAT(mark(x0), mark(sel(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__snd(mark(z0)))), x0, x1, sel(x2, snd(z0))), A__SPLITAT(mark(x0), mark(sel(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, sel(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, sel(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(sel(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__head(mark(z0)))), x0, x1, sel(x2, head(z0))), A__SPLITAT(mark(x0), mark(sel(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__tail(mark(z0)))), x0, x1, sel(x2, tail(z0))), A__SPLITAT(mark(x0), mark(sel(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, sel(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, sel(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, sel(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), cons(mark(z0), z1))), x0, x1, sel(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), s(mark(z0)))), x0, x1, sel(x2, s(z0))), A__SPLITAT(mark(x0), mark(sel(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, sel(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), 0)), x0, x1, sel(x2, 0)), A__SPLITAT(mark(x0), mark(sel(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), nil)), x0, x1, sel(x2, nil)), A__SPLITAT(mark(x0), mark(sel(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__natsFrom(mark(z0)), mark(x3))), x0, x1, sel(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(sel(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__fst(mark(z0)), mark(x3))), x0, x1, sel(fst(z0), x3)), A__SPLITAT(mark(x0), mark(sel(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__snd(mark(z0)), mark(x3))), x0, x1, sel(snd(z0), x3)), A__SPLITAT(mark(x0), mark(sel(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, sel(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(sel(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__head(mark(z0)), mark(x3))), x0, x1, sel(head(z0), x3)), A__SPLITAT(mark(x0), mark(sel(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__tail(mark(z0)), mark(x3))), x0, x1, sel(tail(z0), x3)), A__SPLITAT(mark(x0), mark(sel(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(cons(mark(z0), z1), mark(x3))), x0, x1, sel(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(s(mark(z0)), mark(x3))), x0, x1, sel(s(z0), x3)), A__SPLITAT(mark(x0), mark(sel(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(0, mark(x3))), x0, x1, sel(0, x3)), A__SPLITAT(mark(x0), mark(sel(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(nil, mark(x3))), x0, x1, sel(nil, x3)), A__SPLITAT(mark(x0), mark(sel(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__sel(mark(x2), mark(x3))), natsFrom(z0), x1, sel(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(sel(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__sel(mark(x2), mark(x3))), fst(z0), x1, sel(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(sel(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__sel(mark(x2), mark(x3))), snd(z0), x1, sel(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(sel(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), splitAt(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(sel(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__sel(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, sel(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(sel(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__sel(mark(x2), mark(x3))), head(z0), x1, sel(x2, x3)), A__SPLITAT(mark(head(z0)), mark(sel(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__sel(mark(x2), mark(x3))), tail(z0), x1, sel(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(sel(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), sel(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(sel(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), afterNth(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(sel(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), take(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(sel(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__sel(mark(x2), mark(x3))), cons(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(sel(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__sel(mark(x2), mark(x3))), s(z0), x1, sel(x2, x3)), A__SPLITAT(mark(s(z0)), mark(sel(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), pair(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(sel(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(0, a__sel(mark(x2), mark(x3))), 0, x1, sel(x2, x3)), A__SPLITAT(mark(0), mark(sel(x2, x3))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(nil, a__sel(mark(x2), mark(x3))), nil, x1, sel(x2, x3)), A__SPLITAT(mark(nil), mark(sel(x2, x3))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1, c33_2, c33_1, c7_1


----------------------------------------

(155) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 3 trailing tuple parts
----------------------------------------

(156)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(mark(x0), head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__natsFrom(mark(z0)))), x0, x1, head(natsFrom(z0))), A__SPLITAT(mark(x0), mark(head(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__fst(mark(z0)))), x0, x1, head(fst(z0))), A__SPLITAT(mark(x0), mark(head(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__snd(mark(z0)))), x0, x1, head(snd(z0))), A__SPLITAT(mark(x0), mark(head(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__splitAt(mark(z0), mark(z1)))), x0, x1, head(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(head(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__u(mark(z0), z1, z2, z3))), x0, x1, head(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(head(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__head(mark(z0)))), x0, x1, head(head(z0))), A__SPLITAT(mark(x0), mark(head(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__tail(mark(z0)))), x0, x1, head(tail(z0))), A__SPLITAT(mark(x0), mark(head(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__sel(mark(z0), mark(z1)))), x0, x1, head(sel(z0, z1))), A__SPLITAT(mark(x0), mark(head(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(z0), mark(z1)))), x0, x1, head(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(head(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__take(mark(z0), mark(z1)))), x0, x1, head(take(z0, z1))), A__SPLITAT(mark(x0), mark(head(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(cons(mark(z0), z1))), x0, x1, head(cons(z0, z1))), A__SPLITAT(mark(x0), mark(head(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(s(mark(z0)))), x0, x1, head(s(z0))), A__SPLITAT(mark(x0), mark(head(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(pair(mark(z0), mark(z1)))), x0, x1, head(pair(z0, z1))), A__SPLITAT(mark(x0), mark(head(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(0))) -> c7(A__U(a__splitAt(mark(x0), a__head(0)), x0, x1, head(0)), A__SPLITAT(mark(x0), mark(head(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(nil))) -> c7(A__U(a__splitAt(mark(x0), a__head(nil)), x0, x1, head(nil)), A__SPLITAT(mark(x0), mark(head(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__head(mark(x2))), natsFrom(z0), x1, head(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(head(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__head(mark(x2))), fst(z0), x1, head(x2)), A__SPLITAT(mark(fst(z0)), mark(head(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__head(mark(x2))), snd(z0), x1, head(x2)), A__SPLITAT(mark(snd(z0)), mark(head(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__head(mark(x2))), splitAt(z0, z1), x1, head(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(head(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__head(mark(x2))), u(z0, z1, z2, z3), x1, head(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(head(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__head(mark(x2))), head(z0), x1, head(x2)), A__SPLITAT(mark(head(z0)), mark(head(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__head(mark(x2))), tail(z0), x1, head(x2)), A__SPLITAT(mark(tail(z0)), mark(head(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__head(mark(x2))), sel(z0, z1), x1, head(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(head(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__head(mark(x2))), afterNth(z0, z1), x1, head(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(head(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__head(mark(x2))), take(z0, z1), x1, head(x2)), A__SPLITAT(mark(take(z0, z1)), mark(head(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__head(mark(x2))), cons(z0, z1), x1, head(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(head(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__head(mark(x2))), s(z0), x1, head(x2)), A__SPLITAT(mark(s(z0)), mark(head(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__head(mark(x2))), pair(z0, z1), x1, head(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(head(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(0, a__head(mark(x2))), 0, x1, head(x2)), A__SPLITAT(mark(0), mark(head(x2))))
   A__SPLITAT(s(nil), cons(x1, head(x2))) -> c7(A__U(a__splitAt(nil, a__head(mark(x2))), nil, x1, head(x2)), A__SPLITAT(mark(nil), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(mark(x0), tail(mark(x2))), x0, x1, tail(x2)), A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__natsFrom(mark(z0)))), x0, x1, tail(natsFrom(z0))), A__SPLITAT(mark(x0), mark(tail(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__fst(mark(z0)))), x0, x1, tail(fst(z0))), A__SPLITAT(mark(x0), mark(tail(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__snd(mark(z0)))), x0, x1, tail(snd(z0))), A__SPLITAT(mark(x0), mark(tail(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__splitAt(mark(z0), mark(z1)))), x0, x1, tail(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(tail(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__u(mark(z0), z1, z2, z3))), x0, x1, tail(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(tail(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__head(mark(z0)))), x0, x1, tail(head(z0))), A__SPLITAT(mark(x0), mark(tail(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__tail(mark(z0)))), x0, x1, tail(tail(z0))), A__SPLITAT(mark(x0), mark(tail(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__sel(mark(z0), mark(z1)))), x0, x1, tail(sel(z0, z1))), A__SPLITAT(mark(x0), mark(tail(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__afterNth(mark(z0), mark(z1)))), x0, x1, tail(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(tail(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__take(mark(z0), mark(z1)))), x0, x1, tail(take(z0, z1))), A__SPLITAT(mark(x0), mark(tail(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(cons(mark(z0), z1))), x0, x1, tail(cons(z0, z1))), A__SPLITAT(mark(x0), mark(tail(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(s(mark(z0)))), x0, x1, tail(s(z0))), A__SPLITAT(mark(x0), mark(tail(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(pair(mark(z0), mark(z1)))), x0, x1, tail(pair(z0, z1))), A__SPLITAT(mark(x0), mark(tail(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(0)), x0, x1, tail(0)), A__SPLITAT(mark(x0), mark(tail(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(nil))) -> c7(A__U(a__splitAt(mark(x0), a__tail(nil)), x0, x1, tail(nil)), A__SPLITAT(mark(x0), mark(tail(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__tail(mark(x2))), natsFrom(z0), x1, tail(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(tail(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__tail(mark(x2))), fst(z0), x1, tail(x2)), A__SPLITAT(mark(fst(z0)), mark(tail(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__tail(mark(x2))), snd(z0), x1, tail(x2)), A__SPLITAT(mark(snd(z0)), mark(tail(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__tail(mark(x2))), splitAt(z0, z1), x1, tail(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(tail(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__tail(mark(x2))), u(z0, z1, z2, z3), x1, tail(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(tail(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__tail(mark(x2))), head(z0), x1, tail(x2)), A__SPLITAT(mark(head(z0)), mark(tail(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__tail(mark(x2))), tail(z0), x1, tail(x2)), A__SPLITAT(mark(tail(z0)), mark(tail(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__tail(mark(x2))), sel(z0, z1), x1, tail(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(tail(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__tail(mark(x2))), afterNth(z0, z1), x1, tail(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(tail(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__tail(mark(x2))), take(z0, z1), x1, tail(x2)), A__SPLITAT(mark(take(z0, z1)), mark(tail(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__tail(mark(x2))), cons(z0, z1), x1, tail(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(tail(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__tail(mark(x2))), s(z0), x1, tail(x2)), A__SPLITAT(mark(s(z0)), mark(tail(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__tail(mark(x2))), pair(z0, z1), x1, tail(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(tail(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(0, a__tail(mark(x2))), 0, x1, tail(x2)), A__SPLITAT(mark(0), mark(tail(x2))))
   A__SPLITAT(s(nil), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(nil, a__tail(mark(x2))), nil, x1, tail(x2)), A__SPLITAT(mark(nil), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(mark(x2)), mark(mark(x3))))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), sel(mark(x2), mark(x3))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__natsFrom(mark(z0)))), x0, x1, sel(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(sel(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__fst(mark(z0)))), x0, x1, sel(x2, fst(z0))), A__SPLITAT(mark(x0), mark(sel(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__snd(mark(z0)))), x0, x1, sel(x2, snd(z0))), A__SPLITAT(mark(x0), mark(sel(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, sel(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, sel(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(sel(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__head(mark(z0)))), x0, x1, sel(x2, head(z0))), A__SPLITAT(mark(x0), mark(sel(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__tail(mark(z0)))), x0, x1, sel(x2, tail(z0))), A__SPLITAT(mark(x0), mark(sel(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, sel(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, sel(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, sel(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), cons(mark(z0), z1))), x0, x1, sel(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), s(mark(z0)))), x0, x1, sel(x2, s(z0))), A__SPLITAT(mark(x0), mark(sel(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, sel(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), 0)), x0, x1, sel(x2, 0)), A__SPLITAT(mark(x0), mark(sel(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), nil)), x0, x1, sel(x2, nil)), A__SPLITAT(mark(x0), mark(sel(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__natsFrom(mark(z0)), mark(x3))), x0, x1, sel(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(sel(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__fst(mark(z0)), mark(x3))), x0, x1, sel(fst(z0), x3)), A__SPLITAT(mark(x0), mark(sel(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__snd(mark(z0)), mark(x3))), x0, x1, sel(snd(z0), x3)), A__SPLITAT(mark(x0), mark(sel(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, sel(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(sel(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__head(mark(z0)), mark(x3))), x0, x1, sel(head(z0), x3)), A__SPLITAT(mark(x0), mark(sel(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__tail(mark(z0)), mark(x3))), x0, x1, sel(tail(z0), x3)), A__SPLITAT(mark(x0), mark(sel(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(cons(mark(z0), z1), mark(x3))), x0, x1, sel(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(s(mark(z0)), mark(x3))), x0, x1, sel(s(z0), x3)), A__SPLITAT(mark(x0), mark(sel(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(0, mark(x3))), x0, x1, sel(0, x3)), A__SPLITAT(mark(x0), mark(sel(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(nil, mark(x3))), x0, x1, sel(nil, x3)), A__SPLITAT(mark(x0), mark(sel(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__sel(mark(x2), mark(x3))), natsFrom(z0), x1, sel(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(sel(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__sel(mark(x2), mark(x3))), fst(z0), x1, sel(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(sel(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__sel(mark(x2), mark(x3))), snd(z0), x1, sel(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(sel(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), splitAt(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(sel(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__sel(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, sel(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(sel(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__sel(mark(x2), mark(x3))), head(z0), x1, sel(x2, x3)), A__SPLITAT(mark(head(z0)), mark(sel(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__sel(mark(x2), mark(x3))), tail(z0), x1, sel(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(sel(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), sel(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(sel(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), afterNth(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(sel(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), take(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(sel(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__sel(mark(x2), mark(x3))), cons(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(sel(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__sel(mark(x2), mark(x3))), s(z0), x1, sel(x2, x3)), A__SPLITAT(mark(s(z0)), mark(sel(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), pair(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(sel(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(0, a__sel(mark(x2), mark(x3))), 0, x1, sel(x2, x3)), A__SPLITAT(mark(0), mark(sel(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(nil, a__sel(mark(x2), mark(x3))), nil, x1, sel(x2, x3)), A__SPLITAT(mark(nil), mark(sel(x2, x3))))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(mark(x0), head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__natsFrom(mark(z0)))), x0, x1, head(natsFrom(z0))), A__SPLITAT(mark(x0), mark(head(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__fst(mark(z0)))), x0, x1, head(fst(z0))), A__SPLITAT(mark(x0), mark(head(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__snd(mark(z0)))), x0, x1, head(snd(z0))), A__SPLITAT(mark(x0), mark(head(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__splitAt(mark(z0), mark(z1)))), x0, x1, head(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(head(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__u(mark(z0), z1, z2, z3))), x0, x1, head(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(head(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__head(mark(z0)))), x0, x1, head(head(z0))), A__SPLITAT(mark(x0), mark(head(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__tail(mark(z0)))), x0, x1, head(tail(z0))), A__SPLITAT(mark(x0), mark(head(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__sel(mark(z0), mark(z1)))), x0, x1, head(sel(z0, z1))), A__SPLITAT(mark(x0), mark(head(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(z0), mark(z1)))), x0, x1, head(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(head(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__take(mark(z0), mark(z1)))), x0, x1, head(take(z0, z1))), A__SPLITAT(mark(x0), mark(head(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(cons(mark(z0), z1))), x0, x1, head(cons(z0, z1))), A__SPLITAT(mark(x0), mark(head(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(s(mark(z0)))), x0, x1, head(s(z0))), A__SPLITAT(mark(x0), mark(head(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(pair(mark(z0), mark(z1)))), x0, x1, head(pair(z0, z1))), A__SPLITAT(mark(x0), mark(head(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(0))) -> c7(A__U(a__splitAt(mark(x0), a__head(0)), x0, x1, head(0)), A__SPLITAT(mark(x0), mark(head(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(nil))) -> c7(A__U(a__splitAt(mark(x0), a__head(nil)), x0, x1, head(nil)), A__SPLITAT(mark(x0), mark(head(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__head(mark(x2))), natsFrom(z0), x1, head(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(head(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__head(mark(x2))), fst(z0), x1, head(x2)), A__SPLITAT(mark(fst(z0)), mark(head(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__head(mark(x2))), snd(z0), x1, head(x2)), A__SPLITAT(mark(snd(z0)), mark(head(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__head(mark(x2))), splitAt(z0, z1), x1, head(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(head(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__head(mark(x2))), u(z0, z1, z2, z3), x1, head(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(head(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__head(mark(x2))), head(z0), x1, head(x2)), A__SPLITAT(mark(head(z0)), mark(head(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__head(mark(x2))), tail(z0), x1, head(x2)), A__SPLITAT(mark(tail(z0)), mark(head(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__head(mark(x2))), sel(z0, z1), x1, head(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(head(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__head(mark(x2))), afterNth(z0, z1), x1, head(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(head(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__head(mark(x2))), take(z0, z1), x1, head(x2)), A__SPLITAT(mark(take(z0, z1)), mark(head(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__head(mark(x2))), cons(z0, z1), x1, head(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(head(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__head(mark(x2))), s(z0), x1, head(x2)), A__SPLITAT(mark(s(z0)), mark(head(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__head(mark(x2))), pair(z0, z1), x1, head(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(head(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(0, a__head(mark(x2))), 0, x1, head(x2)), A__SPLITAT(mark(0), mark(head(x2))))
   A__SPLITAT(s(nil), cons(x1, head(x2))) -> c7(A__U(a__splitAt(nil, a__head(mark(x2))), nil, x1, head(x2)), A__SPLITAT(mark(nil), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(mark(x0), tail(mark(x2))), x0, x1, tail(x2)), A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__natsFrom(mark(z0)))), x0, x1, tail(natsFrom(z0))), A__SPLITAT(mark(x0), mark(tail(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__fst(mark(z0)))), x0, x1, tail(fst(z0))), A__SPLITAT(mark(x0), mark(tail(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__snd(mark(z0)))), x0, x1, tail(snd(z0))), A__SPLITAT(mark(x0), mark(tail(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__splitAt(mark(z0), mark(z1)))), x0, x1, tail(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(tail(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__u(mark(z0), z1, z2, z3))), x0, x1, tail(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(tail(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__head(mark(z0)))), x0, x1, tail(head(z0))), A__SPLITAT(mark(x0), mark(tail(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__tail(mark(z0)))), x0, x1, tail(tail(z0))), A__SPLITAT(mark(x0), mark(tail(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__sel(mark(z0), mark(z1)))), x0, x1, tail(sel(z0, z1))), A__SPLITAT(mark(x0), mark(tail(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__afterNth(mark(z0), mark(z1)))), x0, x1, tail(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(tail(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__take(mark(z0), mark(z1)))), x0, x1, tail(take(z0, z1))), A__SPLITAT(mark(x0), mark(tail(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(cons(mark(z0), z1))), x0, x1, tail(cons(z0, z1))), A__SPLITAT(mark(x0), mark(tail(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(s(mark(z0)))), x0, x1, tail(s(z0))), A__SPLITAT(mark(x0), mark(tail(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(pair(mark(z0), mark(z1)))), x0, x1, tail(pair(z0, z1))), A__SPLITAT(mark(x0), mark(tail(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(0)), x0, x1, tail(0)), A__SPLITAT(mark(x0), mark(tail(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(nil))) -> c7(A__U(a__splitAt(mark(x0), a__tail(nil)), x0, x1, tail(nil)), A__SPLITAT(mark(x0), mark(tail(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__tail(mark(x2))), natsFrom(z0), x1, tail(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(tail(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__tail(mark(x2))), fst(z0), x1, tail(x2)), A__SPLITAT(mark(fst(z0)), mark(tail(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__tail(mark(x2))), snd(z0), x1, tail(x2)), A__SPLITAT(mark(snd(z0)), mark(tail(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__tail(mark(x2))), splitAt(z0, z1), x1, tail(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(tail(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__tail(mark(x2))), u(z0, z1, z2, z3), x1, tail(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(tail(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__tail(mark(x2))), head(z0), x1, tail(x2)), A__SPLITAT(mark(head(z0)), mark(tail(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__tail(mark(x2))), tail(z0), x1, tail(x2)), A__SPLITAT(mark(tail(z0)), mark(tail(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__tail(mark(x2))), sel(z0, z1), x1, tail(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(tail(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__tail(mark(x2))), afterNth(z0, z1), x1, tail(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(tail(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__tail(mark(x2))), take(z0, z1), x1, tail(x2)), A__SPLITAT(mark(take(z0, z1)), mark(tail(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__tail(mark(x2))), cons(z0, z1), x1, tail(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(tail(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__tail(mark(x2))), s(z0), x1, tail(x2)), A__SPLITAT(mark(s(z0)), mark(tail(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__tail(mark(x2))), pair(z0, z1), x1, tail(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(tail(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(0, a__tail(mark(x2))), 0, x1, tail(x2)), A__SPLITAT(mark(0), mark(tail(x2))))
   A__SPLITAT(s(nil), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(nil, a__tail(mark(x2))), nil, x1, tail(x2)), A__SPLITAT(mark(nil), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(mark(x2)), mark(mark(x3))))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), sel(mark(x2), mark(x3))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__natsFrom(mark(z0)))), x0, x1, sel(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(sel(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__fst(mark(z0)))), x0, x1, sel(x2, fst(z0))), A__SPLITAT(mark(x0), mark(sel(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__snd(mark(z0)))), x0, x1, sel(x2, snd(z0))), A__SPLITAT(mark(x0), mark(sel(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, sel(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, sel(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(sel(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__head(mark(z0)))), x0, x1, sel(x2, head(z0))), A__SPLITAT(mark(x0), mark(sel(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__tail(mark(z0)))), x0, x1, sel(x2, tail(z0))), A__SPLITAT(mark(x0), mark(sel(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, sel(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, sel(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, sel(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), cons(mark(z0), z1))), x0, x1, sel(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), s(mark(z0)))), x0, x1, sel(x2, s(z0))), A__SPLITAT(mark(x0), mark(sel(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, sel(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), 0)), x0, x1, sel(x2, 0)), A__SPLITAT(mark(x0), mark(sel(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), nil)), x0, x1, sel(x2, nil)), A__SPLITAT(mark(x0), mark(sel(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__natsFrom(mark(z0)), mark(x3))), x0, x1, sel(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(sel(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__fst(mark(z0)), mark(x3))), x0, x1, sel(fst(z0), x3)), A__SPLITAT(mark(x0), mark(sel(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__snd(mark(z0)), mark(x3))), x0, x1, sel(snd(z0), x3)), A__SPLITAT(mark(x0), mark(sel(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, sel(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(sel(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__head(mark(z0)), mark(x3))), x0, x1, sel(head(z0), x3)), A__SPLITAT(mark(x0), mark(sel(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__tail(mark(z0)), mark(x3))), x0, x1, sel(tail(z0), x3)), A__SPLITAT(mark(x0), mark(sel(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(cons(mark(z0), z1), mark(x3))), x0, x1, sel(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(s(mark(z0)), mark(x3))), x0, x1, sel(s(z0), x3)), A__SPLITAT(mark(x0), mark(sel(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(0, mark(x3))), x0, x1, sel(0, x3)), A__SPLITAT(mark(x0), mark(sel(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(nil, mark(x3))), x0, x1, sel(nil, x3)), A__SPLITAT(mark(x0), mark(sel(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__sel(mark(x2), mark(x3))), natsFrom(z0), x1, sel(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(sel(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__sel(mark(x2), mark(x3))), fst(z0), x1, sel(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(sel(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__sel(mark(x2), mark(x3))), snd(z0), x1, sel(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(sel(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), splitAt(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(sel(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__sel(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, sel(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(sel(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__sel(mark(x2), mark(x3))), head(z0), x1, sel(x2, x3)), A__SPLITAT(mark(head(z0)), mark(sel(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__sel(mark(x2), mark(x3))), tail(z0), x1, sel(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(sel(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), sel(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(sel(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), afterNth(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(sel(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), take(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(sel(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__sel(mark(x2), mark(x3))), cons(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(sel(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__sel(mark(x2), mark(x3))), s(z0), x1, sel(x2, x3)), A__SPLITAT(mark(s(z0)), mark(sel(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), pair(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(sel(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(0, a__sel(mark(x2), mark(x3))), 0, x1, sel(x2, x3)), A__SPLITAT(mark(0), mark(sel(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(nil, a__sel(mark(x2), mark(x3))), nil, x1, sel(x2, x3)), A__SPLITAT(mark(nil), mark(sel(x2, x3))))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1, c33_2, c33_1, c7_1


----------------------------------------

(157) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0)) by 
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(splitAt(mark(x0), a__afterNth(mark(x2), mark(x3))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(mark(x2)), mark(mark(x3))))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), afterNth(mark(x2), mark(x3))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__natsFrom(mark(z0)))), x0, x1, afterNth(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__fst(mark(z0)))), x0, x1, afterNth(x2, fst(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__snd(mark(z0)))), x0, x1, afterNth(x2, snd(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, afterNth(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, afterNth(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(afterNth(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__head(mark(z0)))), x0, x1, afterNth(x2, head(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__tail(mark(z0)))), x0, x1, afterNth(x2, tail(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, afterNth(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, afterNth(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, afterNth(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), cons(mark(z0), z1))), x0, x1, afterNth(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), s(mark(z0)))), x0, x1, afterNth(x2, s(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, afterNth(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), 0)), x0, x1, afterNth(x2, 0)), A__SPLITAT(mark(x0), mark(afterNth(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), nil)), x0, x1, afterNth(x2, nil)), A__SPLITAT(mark(x0), mark(afterNth(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__natsFrom(mark(z0)), mark(x3))), x0, x1, afterNth(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__fst(mark(z0)), mark(x3))), x0, x1, afterNth(fst(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__snd(mark(z0)), mark(x3))), x0, x1, afterNth(snd(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, afterNth(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(afterNth(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__head(mark(z0)), mark(x3))), x0, x1, afterNth(head(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__tail(mark(z0)), mark(x3))), x0, x1, afterNth(tail(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(cons(mark(z0), z1), mark(x3))), x0, x1, afterNth(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(s(mark(z0)), mark(x3))), x0, x1, afterNth(s(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(0, mark(x3))), x0, x1, afterNth(0, x3)), A__SPLITAT(mark(x0), mark(afterNth(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(nil, mark(x3))), x0, x1, afterNth(nil, x3)), A__SPLITAT(mark(x0), mark(afterNth(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__afterNth(mark(x2), mark(x3))), natsFrom(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(afterNth(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__afterNth(mark(x2), mark(x3))), fst(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(afterNth(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__afterNth(mark(x2), mark(x3))), snd(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(afterNth(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), splitAt(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(afterNth(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__afterNth(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, afterNth(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(afterNth(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__afterNth(mark(x2), mark(x3))), head(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(head(z0)), mark(afterNth(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__afterNth(mark(x2), mark(x3))), tail(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(afterNth(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), sel(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(afterNth(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), afterNth(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(afterNth(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), take(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(afterNth(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__afterNth(mark(x2), mark(x3))), cons(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(afterNth(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__afterNth(mark(x2), mark(x3))), s(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(s(z0)), mark(afterNth(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), pair(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(afterNth(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(0, a__afterNth(mark(x2), mark(x3))), 0, x1, afterNth(x2, x3)), A__SPLITAT(mark(0), mark(afterNth(x2, x3))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(nil, a__afterNth(mark(x2), mark(x3))), nil, x1, afterNth(x2, x3)), A__SPLITAT(mark(nil), mark(afterNth(x2, x3))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(afterNth(x2, x3))))

----------------------------------------

(158)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(mark(x0), head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__natsFrom(mark(z0)))), x0, x1, head(natsFrom(z0))), A__SPLITAT(mark(x0), mark(head(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__fst(mark(z0)))), x0, x1, head(fst(z0))), A__SPLITAT(mark(x0), mark(head(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__snd(mark(z0)))), x0, x1, head(snd(z0))), A__SPLITAT(mark(x0), mark(head(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__splitAt(mark(z0), mark(z1)))), x0, x1, head(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(head(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__u(mark(z0), z1, z2, z3))), x0, x1, head(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(head(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__head(mark(z0)))), x0, x1, head(head(z0))), A__SPLITAT(mark(x0), mark(head(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__tail(mark(z0)))), x0, x1, head(tail(z0))), A__SPLITAT(mark(x0), mark(head(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__sel(mark(z0), mark(z1)))), x0, x1, head(sel(z0, z1))), A__SPLITAT(mark(x0), mark(head(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(z0), mark(z1)))), x0, x1, head(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(head(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__take(mark(z0), mark(z1)))), x0, x1, head(take(z0, z1))), A__SPLITAT(mark(x0), mark(head(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(cons(mark(z0), z1))), x0, x1, head(cons(z0, z1))), A__SPLITAT(mark(x0), mark(head(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(s(mark(z0)))), x0, x1, head(s(z0))), A__SPLITAT(mark(x0), mark(head(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(pair(mark(z0), mark(z1)))), x0, x1, head(pair(z0, z1))), A__SPLITAT(mark(x0), mark(head(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(0))) -> c7(A__U(a__splitAt(mark(x0), a__head(0)), x0, x1, head(0)), A__SPLITAT(mark(x0), mark(head(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(nil))) -> c7(A__U(a__splitAt(mark(x0), a__head(nil)), x0, x1, head(nil)), A__SPLITAT(mark(x0), mark(head(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__head(mark(x2))), natsFrom(z0), x1, head(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(head(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__head(mark(x2))), fst(z0), x1, head(x2)), A__SPLITAT(mark(fst(z0)), mark(head(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__head(mark(x2))), snd(z0), x1, head(x2)), A__SPLITAT(mark(snd(z0)), mark(head(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__head(mark(x2))), splitAt(z0, z1), x1, head(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(head(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__head(mark(x2))), u(z0, z1, z2, z3), x1, head(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(head(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__head(mark(x2))), head(z0), x1, head(x2)), A__SPLITAT(mark(head(z0)), mark(head(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__head(mark(x2))), tail(z0), x1, head(x2)), A__SPLITAT(mark(tail(z0)), mark(head(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__head(mark(x2))), sel(z0, z1), x1, head(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(head(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__head(mark(x2))), afterNth(z0, z1), x1, head(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(head(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__head(mark(x2))), take(z0, z1), x1, head(x2)), A__SPLITAT(mark(take(z0, z1)), mark(head(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__head(mark(x2))), cons(z0, z1), x1, head(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(head(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__head(mark(x2))), s(z0), x1, head(x2)), A__SPLITAT(mark(s(z0)), mark(head(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__head(mark(x2))), pair(z0, z1), x1, head(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(head(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(0, a__head(mark(x2))), 0, x1, head(x2)), A__SPLITAT(mark(0), mark(head(x2))))
   A__SPLITAT(s(nil), cons(x1, head(x2))) -> c7(A__U(a__splitAt(nil, a__head(mark(x2))), nil, x1, head(x2)), A__SPLITAT(mark(nil), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(mark(x0), tail(mark(x2))), x0, x1, tail(x2)), A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__natsFrom(mark(z0)))), x0, x1, tail(natsFrom(z0))), A__SPLITAT(mark(x0), mark(tail(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__fst(mark(z0)))), x0, x1, tail(fst(z0))), A__SPLITAT(mark(x0), mark(tail(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__snd(mark(z0)))), x0, x1, tail(snd(z0))), A__SPLITAT(mark(x0), mark(tail(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__splitAt(mark(z0), mark(z1)))), x0, x1, tail(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(tail(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__u(mark(z0), z1, z2, z3))), x0, x1, tail(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(tail(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__head(mark(z0)))), x0, x1, tail(head(z0))), A__SPLITAT(mark(x0), mark(tail(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__tail(mark(z0)))), x0, x1, tail(tail(z0))), A__SPLITAT(mark(x0), mark(tail(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__sel(mark(z0), mark(z1)))), x0, x1, tail(sel(z0, z1))), A__SPLITAT(mark(x0), mark(tail(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__afterNth(mark(z0), mark(z1)))), x0, x1, tail(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(tail(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__take(mark(z0), mark(z1)))), x0, x1, tail(take(z0, z1))), A__SPLITAT(mark(x0), mark(tail(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(cons(mark(z0), z1))), x0, x1, tail(cons(z0, z1))), A__SPLITAT(mark(x0), mark(tail(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(s(mark(z0)))), x0, x1, tail(s(z0))), A__SPLITAT(mark(x0), mark(tail(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(pair(mark(z0), mark(z1)))), x0, x1, tail(pair(z0, z1))), A__SPLITAT(mark(x0), mark(tail(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(0)), x0, x1, tail(0)), A__SPLITAT(mark(x0), mark(tail(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(nil))) -> c7(A__U(a__splitAt(mark(x0), a__tail(nil)), x0, x1, tail(nil)), A__SPLITAT(mark(x0), mark(tail(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__tail(mark(x2))), natsFrom(z0), x1, tail(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(tail(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__tail(mark(x2))), fst(z0), x1, tail(x2)), A__SPLITAT(mark(fst(z0)), mark(tail(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__tail(mark(x2))), snd(z0), x1, tail(x2)), A__SPLITAT(mark(snd(z0)), mark(tail(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__tail(mark(x2))), splitAt(z0, z1), x1, tail(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(tail(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__tail(mark(x2))), u(z0, z1, z2, z3), x1, tail(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(tail(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__tail(mark(x2))), head(z0), x1, tail(x2)), A__SPLITAT(mark(head(z0)), mark(tail(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__tail(mark(x2))), tail(z0), x1, tail(x2)), A__SPLITAT(mark(tail(z0)), mark(tail(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__tail(mark(x2))), sel(z0, z1), x1, tail(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(tail(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__tail(mark(x2))), afterNth(z0, z1), x1, tail(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(tail(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__tail(mark(x2))), take(z0, z1), x1, tail(x2)), A__SPLITAT(mark(take(z0, z1)), mark(tail(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__tail(mark(x2))), cons(z0, z1), x1, tail(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(tail(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__tail(mark(x2))), s(z0), x1, tail(x2)), A__SPLITAT(mark(s(z0)), mark(tail(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__tail(mark(x2))), pair(z0, z1), x1, tail(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(tail(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(0, a__tail(mark(x2))), 0, x1, tail(x2)), A__SPLITAT(mark(0), mark(tail(x2))))
   A__SPLITAT(s(nil), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(nil, a__tail(mark(x2))), nil, x1, tail(x2)), A__SPLITAT(mark(nil), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(mark(x2)), mark(mark(x3))))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), sel(mark(x2), mark(x3))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__natsFrom(mark(z0)))), x0, x1, sel(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(sel(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__fst(mark(z0)))), x0, x1, sel(x2, fst(z0))), A__SPLITAT(mark(x0), mark(sel(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__snd(mark(z0)))), x0, x1, sel(x2, snd(z0))), A__SPLITAT(mark(x0), mark(sel(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, sel(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, sel(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(sel(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__head(mark(z0)))), x0, x1, sel(x2, head(z0))), A__SPLITAT(mark(x0), mark(sel(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__tail(mark(z0)))), x0, x1, sel(x2, tail(z0))), A__SPLITAT(mark(x0), mark(sel(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, sel(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, sel(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, sel(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), cons(mark(z0), z1))), x0, x1, sel(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), s(mark(z0)))), x0, x1, sel(x2, s(z0))), A__SPLITAT(mark(x0), mark(sel(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, sel(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), 0)), x0, x1, sel(x2, 0)), A__SPLITAT(mark(x0), mark(sel(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), nil)), x0, x1, sel(x2, nil)), A__SPLITAT(mark(x0), mark(sel(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__natsFrom(mark(z0)), mark(x3))), x0, x1, sel(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(sel(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__fst(mark(z0)), mark(x3))), x0, x1, sel(fst(z0), x3)), A__SPLITAT(mark(x0), mark(sel(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__snd(mark(z0)), mark(x3))), x0, x1, sel(snd(z0), x3)), A__SPLITAT(mark(x0), mark(sel(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, sel(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(sel(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__head(mark(z0)), mark(x3))), x0, x1, sel(head(z0), x3)), A__SPLITAT(mark(x0), mark(sel(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__tail(mark(z0)), mark(x3))), x0, x1, sel(tail(z0), x3)), A__SPLITAT(mark(x0), mark(sel(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(cons(mark(z0), z1), mark(x3))), x0, x1, sel(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(s(mark(z0)), mark(x3))), x0, x1, sel(s(z0), x3)), A__SPLITAT(mark(x0), mark(sel(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(0, mark(x3))), x0, x1, sel(0, x3)), A__SPLITAT(mark(x0), mark(sel(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(nil, mark(x3))), x0, x1, sel(nil, x3)), A__SPLITAT(mark(x0), mark(sel(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__sel(mark(x2), mark(x3))), natsFrom(z0), x1, sel(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(sel(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__sel(mark(x2), mark(x3))), fst(z0), x1, sel(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(sel(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__sel(mark(x2), mark(x3))), snd(z0), x1, sel(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(sel(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), splitAt(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(sel(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__sel(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, sel(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(sel(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__sel(mark(x2), mark(x3))), head(z0), x1, sel(x2, x3)), A__SPLITAT(mark(head(z0)), mark(sel(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__sel(mark(x2), mark(x3))), tail(z0), x1, sel(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(sel(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), sel(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(sel(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), afterNth(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(sel(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), take(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(sel(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__sel(mark(x2), mark(x3))), cons(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(sel(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__sel(mark(x2), mark(x3))), s(z0), x1, sel(x2, x3)), A__SPLITAT(mark(s(z0)), mark(sel(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), pair(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(sel(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(0, a__sel(mark(x2), mark(x3))), 0, x1, sel(x2, x3)), A__SPLITAT(mark(0), mark(sel(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(nil, a__sel(mark(x2), mark(x3))), nil, x1, sel(x2, x3)), A__SPLITAT(mark(nil), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(splitAt(mark(x0), a__afterNth(mark(x2), mark(x3))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(mark(x2)), mark(mark(x3))))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), afterNth(mark(x2), mark(x3))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__natsFrom(mark(z0)))), x0, x1, afterNth(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__fst(mark(z0)))), x0, x1, afterNth(x2, fst(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__snd(mark(z0)))), x0, x1, afterNth(x2, snd(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, afterNth(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, afterNth(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(afterNth(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__head(mark(z0)))), x0, x1, afterNth(x2, head(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__tail(mark(z0)))), x0, x1, afterNth(x2, tail(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, afterNth(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, afterNth(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, afterNth(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), cons(mark(z0), z1))), x0, x1, afterNth(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), s(mark(z0)))), x0, x1, afterNth(x2, s(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, afterNth(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), 0)), x0, x1, afterNth(x2, 0)), A__SPLITAT(mark(x0), mark(afterNth(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), nil)), x0, x1, afterNth(x2, nil)), A__SPLITAT(mark(x0), mark(afterNth(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__natsFrom(mark(z0)), mark(x3))), x0, x1, afterNth(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__fst(mark(z0)), mark(x3))), x0, x1, afterNth(fst(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__snd(mark(z0)), mark(x3))), x0, x1, afterNth(snd(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, afterNth(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(afterNth(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__head(mark(z0)), mark(x3))), x0, x1, afterNth(head(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__tail(mark(z0)), mark(x3))), x0, x1, afterNth(tail(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(cons(mark(z0), z1), mark(x3))), x0, x1, afterNth(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(s(mark(z0)), mark(x3))), x0, x1, afterNth(s(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(0, mark(x3))), x0, x1, afterNth(0, x3)), A__SPLITAT(mark(x0), mark(afterNth(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(nil, mark(x3))), x0, x1, afterNth(nil, x3)), A__SPLITAT(mark(x0), mark(afterNth(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__afterNth(mark(x2), mark(x3))), natsFrom(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(afterNth(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__afterNth(mark(x2), mark(x3))), fst(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(afterNth(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__afterNth(mark(x2), mark(x3))), snd(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(afterNth(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), splitAt(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(afterNth(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__afterNth(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, afterNth(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(afterNth(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__afterNth(mark(x2), mark(x3))), head(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(head(z0)), mark(afterNth(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__afterNth(mark(x2), mark(x3))), tail(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(afterNth(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), sel(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(afterNth(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), afterNth(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(afterNth(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), take(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(afterNth(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__afterNth(mark(x2), mark(x3))), cons(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(afterNth(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__afterNth(mark(x2), mark(x3))), s(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(s(z0)), mark(afterNth(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), pair(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(afterNth(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(0, a__afterNth(mark(x2), mark(x3))), 0, x1, afterNth(x2, x3)), A__SPLITAT(mark(0), mark(afterNth(x2, x3))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(nil, a__afterNth(mark(x2), mark(x3))), nil, x1, afterNth(x2, x3)), A__SPLITAT(mark(nil), mark(afterNth(x2, x3))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(afterNth(x2, x3))))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(mark(x0), head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__natsFrom(mark(z0)))), x0, x1, head(natsFrom(z0))), A__SPLITAT(mark(x0), mark(head(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__fst(mark(z0)))), x0, x1, head(fst(z0))), A__SPLITAT(mark(x0), mark(head(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__snd(mark(z0)))), x0, x1, head(snd(z0))), A__SPLITAT(mark(x0), mark(head(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__splitAt(mark(z0), mark(z1)))), x0, x1, head(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(head(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__u(mark(z0), z1, z2, z3))), x0, x1, head(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(head(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__head(mark(z0)))), x0, x1, head(head(z0))), A__SPLITAT(mark(x0), mark(head(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__tail(mark(z0)))), x0, x1, head(tail(z0))), A__SPLITAT(mark(x0), mark(head(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__sel(mark(z0), mark(z1)))), x0, x1, head(sel(z0, z1))), A__SPLITAT(mark(x0), mark(head(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(z0), mark(z1)))), x0, x1, head(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(head(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__take(mark(z0), mark(z1)))), x0, x1, head(take(z0, z1))), A__SPLITAT(mark(x0), mark(head(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(cons(mark(z0), z1))), x0, x1, head(cons(z0, z1))), A__SPLITAT(mark(x0), mark(head(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(s(mark(z0)))), x0, x1, head(s(z0))), A__SPLITAT(mark(x0), mark(head(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(pair(mark(z0), mark(z1)))), x0, x1, head(pair(z0, z1))), A__SPLITAT(mark(x0), mark(head(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(0))) -> c7(A__U(a__splitAt(mark(x0), a__head(0)), x0, x1, head(0)), A__SPLITAT(mark(x0), mark(head(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(nil))) -> c7(A__U(a__splitAt(mark(x0), a__head(nil)), x0, x1, head(nil)), A__SPLITAT(mark(x0), mark(head(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__head(mark(x2))), natsFrom(z0), x1, head(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(head(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__head(mark(x2))), fst(z0), x1, head(x2)), A__SPLITAT(mark(fst(z0)), mark(head(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__head(mark(x2))), snd(z0), x1, head(x2)), A__SPLITAT(mark(snd(z0)), mark(head(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__head(mark(x2))), splitAt(z0, z1), x1, head(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(head(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__head(mark(x2))), u(z0, z1, z2, z3), x1, head(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(head(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__head(mark(x2))), head(z0), x1, head(x2)), A__SPLITAT(mark(head(z0)), mark(head(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__head(mark(x2))), tail(z0), x1, head(x2)), A__SPLITAT(mark(tail(z0)), mark(head(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__head(mark(x2))), sel(z0, z1), x1, head(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(head(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__head(mark(x2))), afterNth(z0, z1), x1, head(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(head(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__head(mark(x2))), take(z0, z1), x1, head(x2)), A__SPLITAT(mark(take(z0, z1)), mark(head(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__head(mark(x2))), cons(z0, z1), x1, head(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(head(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__head(mark(x2))), s(z0), x1, head(x2)), A__SPLITAT(mark(s(z0)), mark(head(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__head(mark(x2))), pair(z0, z1), x1, head(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(head(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(0, a__head(mark(x2))), 0, x1, head(x2)), A__SPLITAT(mark(0), mark(head(x2))))
   A__SPLITAT(s(nil), cons(x1, head(x2))) -> c7(A__U(a__splitAt(nil, a__head(mark(x2))), nil, x1, head(x2)), A__SPLITAT(mark(nil), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(mark(x0), tail(mark(x2))), x0, x1, tail(x2)), A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__natsFrom(mark(z0)))), x0, x1, tail(natsFrom(z0))), A__SPLITAT(mark(x0), mark(tail(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__fst(mark(z0)))), x0, x1, tail(fst(z0))), A__SPLITAT(mark(x0), mark(tail(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__snd(mark(z0)))), x0, x1, tail(snd(z0))), A__SPLITAT(mark(x0), mark(tail(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__splitAt(mark(z0), mark(z1)))), x0, x1, tail(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(tail(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__u(mark(z0), z1, z2, z3))), x0, x1, tail(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(tail(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__head(mark(z0)))), x0, x1, tail(head(z0))), A__SPLITAT(mark(x0), mark(tail(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__tail(mark(z0)))), x0, x1, tail(tail(z0))), A__SPLITAT(mark(x0), mark(tail(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__sel(mark(z0), mark(z1)))), x0, x1, tail(sel(z0, z1))), A__SPLITAT(mark(x0), mark(tail(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__afterNth(mark(z0), mark(z1)))), x0, x1, tail(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(tail(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__take(mark(z0), mark(z1)))), x0, x1, tail(take(z0, z1))), A__SPLITAT(mark(x0), mark(tail(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(cons(mark(z0), z1))), x0, x1, tail(cons(z0, z1))), A__SPLITAT(mark(x0), mark(tail(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(s(mark(z0)))), x0, x1, tail(s(z0))), A__SPLITAT(mark(x0), mark(tail(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(pair(mark(z0), mark(z1)))), x0, x1, tail(pair(z0, z1))), A__SPLITAT(mark(x0), mark(tail(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(0)), x0, x1, tail(0)), A__SPLITAT(mark(x0), mark(tail(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(nil))) -> c7(A__U(a__splitAt(mark(x0), a__tail(nil)), x0, x1, tail(nil)), A__SPLITAT(mark(x0), mark(tail(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__tail(mark(x2))), natsFrom(z0), x1, tail(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(tail(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__tail(mark(x2))), fst(z0), x1, tail(x2)), A__SPLITAT(mark(fst(z0)), mark(tail(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__tail(mark(x2))), snd(z0), x1, tail(x2)), A__SPLITAT(mark(snd(z0)), mark(tail(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__tail(mark(x2))), splitAt(z0, z1), x1, tail(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(tail(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__tail(mark(x2))), u(z0, z1, z2, z3), x1, tail(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(tail(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__tail(mark(x2))), head(z0), x1, tail(x2)), A__SPLITAT(mark(head(z0)), mark(tail(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__tail(mark(x2))), tail(z0), x1, tail(x2)), A__SPLITAT(mark(tail(z0)), mark(tail(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__tail(mark(x2))), sel(z0, z1), x1, tail(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(tail(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__tail(mark(x2))), afterNth(z0, z1), x1, tail(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(tail(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__tail(mark(x2))), take(z0, z1), x1, tail(x2)), A__SPLITAT(mark(take(z0, z1)), mark(tail(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__tail(mark(x2))), cons(z0, z1), x1, tail(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(tail(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__tail(mark(x2))), s(z0), x1, tail(x2)), A__SPLITAT(mark(s(z0)), mark(tail(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__tail(mark(x2))), pair(z0, z1), x1, tail(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(tail(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(0, a__tail(mark(x2))), 0, x1, tail(x2)), A__SPLITAT(mark(0), mark(tail(x2))))
   A__SPLITAT(s(nil), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(nil, a__tail(mark(x2))), nil, x1, tail(x2)), A__SPLITAT(mark(nil), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(mark(x2)), mark(mark(x3))))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), sel(mark(x2), mark(x3))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__natsFrom(mark(z0)))), x0, x1, sel(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(sel(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__fst(mark(z0)))), x0, x1, sel(x2, fst(z0))), A__SPLITAT(mark(x0), mark(sel(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__snd(mark(z0)))), x0, x1, sel(x2, snd(z0))), A__SPLITAT(mark(x0), mark(sel(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, sel(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, sel(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(sel(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__head(mark(z0)))), x0, x1, sel(x2, head(z0))), A__SPLITAT(mark(x0), mark(sel(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__tail(mark(z0)))), x0, x1, sel(x2, tail(z0))), A__SPLITAT(mark(x0), mark(sel(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, sel(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, sel(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, sel(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), cons(mark(z0), z1))), x0, x1, sel(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), s(mark(z0)))), x0, x1, sel(x2, s(z0))), A__SPLITAT(mark(x0), mark(sel(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, sel(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), 0)), x0, x1, sel(x2, 0)), A__SPLITAT(mark(x0), mark(sel(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), nil)), x0, x1, sel(x2, nil)), A__SPLITAT(mark(x0), mark(sel(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__natsFrom(mark(z0)), mark(x3))), x0, x1, sel(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(sel(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__fst(mark(z0)), mark(x3))), x0, x1, sel(fst(z0), x3)), A__SPLITAT(mark(x0), mark(sel(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__snd(mark(z0)), mark(x3))), x0, x1, sel(snd(z0), x3)), A__SPLITAT(mark(x0), mark(sel(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, sel(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(sel(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__head(mark(z0)), mark(x3))), x0, x1, sel(head(z0), x3)), A__SPLITAT(mark(x0), mark(sel(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__tail(mark(z0)), mark(x3))), x0, x1, sel(tail(z0), x3)), A__SPLITAT(mark(x0), mark(sel(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(cons(mark(z0), z1), mark(x3))), x0, x1, sel(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(s(mark(z0)), mark(x3))), x0, x1, sel(s(z0), x3)), A__SPLITAT(mark(x0), mark(sel(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(0, mark(x3))), x0, x1, sel(0, x3)), A__SPLITAT(mark(x0), mark(sel(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(nil, mark(x3))), x0, x1, sel(nil, x3)), A__SPLITAT(mark(x0), mark(sel(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__sel(mark(x2), mark(x3))), natsFrom(z0), x1, sel(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(sel(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__sel(mark(x2), mark(x3))), fst(z0), x1, sel(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(sel(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__sel(mark(x2), mark(x3))), snd(z0), x1, sel(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(sel(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), splitAt(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(sel(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__sel(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, sel(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(sel(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__sel(mark(x2), mark(x3))), head(z0), x1, sel(x2, x3)), A__SPLITAT(mark(head(z0)), mark(sel(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__sel(mark(x2), mark(x3))), tail(z0), x1, sel(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(sel(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), sel(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(sel(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), afterNth(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(sel(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), take(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(sel(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__sel(mark(x2), mark(x3))), cons(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(sel(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__sel(mark(x2), mark(x3))), s(z0), x1, sel(x2, x3)), A__SPLITAT(mark(s(z0)), mark(sel(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), pair(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(sel(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(0, a__sel(mark(x2), mark(x3))), 0, x1, sel(x2, x3)), A__SPLITAT(mark(0), mark(sel(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(nil, a__sel(mark(x2), mark(x3))), nil, x1, sel(x2, x3)), A__SPLITAT(mark(nil), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(splitAt(mark(x0), a__afterNth(mark(x2), mark(x3))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(mark(x2)), mark(mark(x3))))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), afterNth(mark(x2), mark(x3))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__natsFrom(mark(z0)))), x0, x1, afterNth(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__fst(mark(z0)))), x0, x1, afterNth(x2, fst(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__snd(mark(z0)))), x0, x1, afterNth(x2, snd(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, afterNth(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, afterNth(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(afterNth(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__head(mark(z0)))), x0, x1, afterNth(x2, head(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__tail(mark(z0)))), x0, x1, afterNth(x2, tail(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, afterNth(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, afterNth(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, afterNth(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), cons(mark(z0), z1))), x0, x1, afterNth(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), s(mark(z0)))), x0, x1, afterNth(x2, s(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, afterNth(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), 0)), x0, x1, afterNth(x2, 0)), A__SPLITAT(mark(x0), mark(afterNth(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), nil)), x0, x1, afterNth(x2, nil)), A__SPLITAT(mark(x0), mark(afterNth(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__natsFrom(mark(z0)), mark(x3))), x0, x1, afterNth(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__fst(mark(z0)), mark(x3))), x0, x1, afterNth(fst(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__snd(mark(z0)), mark(x3))), x0, x1, afterNth(snd(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, afterNth(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(afterNth(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__head(mark(z0)), mark(x3))), x0, x1, afterNth(head(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__tail(mark(z0)), mark(x3))), x0, x1, afterNth(tail(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(cons(mark(z0), z1), mark(x3))), x0, x1, afterNth(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(s(mark(z0)), mark(x3))), x0, x1, afterNth(s(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(0, mark(x3))), x0, x1, afterNth(0, x3)), A__SPLITAT(mark(x0), mark(afterNth(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(nil, mark(x3))), x0, x1, afterNth(nil, x3)), A__SPLITAT(mark(x0), mark(afterNth(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__afterNth(mark(x2), mark(x3))), natsFrom(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(afterNth(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__afterNth(mark(x2), mark(x3))), fst(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(afterNth(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__afterNth(mark(x2), mark(x3))), snd(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(afterNth(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), splitAt(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(afterNth(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__afterNth(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, afterNth(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(afterNth(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__afterNth(mark(x2), mark(x3))), head(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(head(z0)), mark(afterNth(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__afterNth(mark(x2), mark(x3))), tail(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(afterNth(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), sel(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(afterNth(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), afterNth(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(afterNth(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), take(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(afterNth(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__afterNth(mark(x2), mark(x3))), cons(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(afterNth(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__afterNth(mark(x2), mark(x3))), s(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(s(z0)), mark(afterNth(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), pair(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(afterNth(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(0, a__afterNth(mark(x2), mark(x3))), 0, x1, afterNth(x2, x3)), A__SPLITAT(mark(0), mark(afterNth(x2, x3))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(nil, a__afterNth(mark(x2), mark(x3))), nil, x1, afterNth(x2, x3)), A__SPLITAT(mark(nil), mark(afterNth(x2, x3))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(afterNth(x2, x3))))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1, c33_2, c33_1, c7_1


----------------------------------------

(159) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 3 trailing tuple parts
----------------------------------------

(160)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(mark(x0), head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__natsFrom(mark(z0)))), x0, x1, head(natsFrom(z0))), A__SPLITAT(mark(x0), mark(head(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__fst(mark(z0)))), x0, x1, head(fst(z0))), A__SPLITAT(mark(x0), mark(head(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__snd(mark(z0)))), x0, x1, head(snd(z0))), A__SPLITAT(mark(x0), mark(head(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__splitAt(mark(z0), mark(z1)))), x0, x1, head(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(head(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__u(mark(z0), z1, z2, z3))), x0, x1, head(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(head(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__head(mark(z0)))), x0, x1, head(head(z0))), A__SPLITAT(mark(x0), mark(head(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__tail(mark(z0)))), x0, x1, head(tail(z0))), A__SPLITAT(mark(x0), mark(head(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__sel(mark(z0), mark(z1)))), x0, x1, head(sel(z0, z1))), A__SPLITAT(mark(x0), mark(head(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(z0), mark(z1)))), x0, x1, head(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(head(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__take(mark(z0), mark(z1)))), x0, x1, head(take(z0, z1))), A__SPLITAT(mark(x0), mark(head(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(cons(mark(z0), z1))), x0, x1, head(cons(z0, z1))), A__SPLITAT(mark(x0), mark(head(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(s(mark(z0)))), x0, x1, head(s(z0))), A__SPLITAT(mark(x0), mark(head(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(pair(mark(z0), mark(z1)))), x0, x1, head(pair(z0, z1))), A__SPLITAT(mark(x0), mark(head(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(0))) -> c7(A__U(a__splitAt(mark(x0), a__head(0)), x0, x1, head(0)), A__SPLITAT(mark(x0), mark(head(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(nil))) -> c7(A__U(a__splitAt(mark(x0), a__head(nil)), x0, x1, head(nil)), A__SPLITAT(mark(x0), mark(head(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__head(mark(x2))), natsFrom(z0), x1, head(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(head(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__head(mark(x2))), fst(z0), x1, head(x2)), A__SPLITAT(mark(fst(z0)), mark(head(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__head(mark(x2))), snd(z0), x1, head(x2)), A__SPLITAT(mark(snd(z0)), mark(head(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__head(mark(x2))), splitAt(z0, z1), x1, head(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(head(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__head(mark(x2))), u(z0, z1, z2, z3), x1, head(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(head(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__head(mark(x2))), head(z0), x1, head(x2)), A__SPLITAT(mark(head(z0)), mark(head(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__head(mark(x2))), tail(z0), x1, head(x2)), A__SPLITAT(mark(tail(z0)), mark(head(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__head(mark(x2))), sel(z0, z1), x1, head(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(head(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__head(mark(x2))), afterNth(z0, z1), x1, head(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(head(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__head(mark(x2))), take(z0, z1), x1, head(x2)), A__SPLITAT(mark(take(z0, z1)), mark(head(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__head(mark(x2))), cons(z0, z1), x1, head(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(head(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__head(mark(x2))), s(z0), x1, head(x2)), A__SPLITAT(mark(s(z0)), mark(head(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__head(mark(x2))), pair(z0, z1), x1, head(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(head(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(0, a__head(mark(x2))), 0, x1, head(x2)), A__SPLITAT(mark(0), mark(head(x2))))
   A__SPLITAT(s(nil), cons(x1, head(x2))) -> c7(A__U(a__splitAt(nil, a__head(mark(x2))), nil, x1, head(x2)), A__SPLITAT(mark(nil), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(mark(x0), tail(mark(x2))), x0, x1, tail(x2)), A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__natsFrom(mark(z0)))), x0, x1, tail(natsFrom(z0))), A__SPLITAT(mark(x0), mark(tail(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__fst(mark(z0)))), x0, x1, tail(fst(z0))), A__SPLITAT(mark(x0), mark(tail(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__snd(mark(z0)))), x0, x1, tail(snd(z0))), A__SPLITAT(mark(x0), mark(tail(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__splitAt(mark(z0), mark(z1)))), x0, x1, tail(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(tail(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__u(mark(z0), z1, z2, z3))), x0, x1, tail(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(tail(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__head(mark(z0)))), x0, x1, tail(head(z0))), A__SPLITAT(mark(x0), mark(tail(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__tail(mark(z0)))), x0, x1, tail(tail(z0))), A__SPLITAT(mark(x0), mark(tail(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__sel(mark(z0), mark(z1)))), x0, x1, tail(sel(z0, z1))), A__SPLITAT(mark(x0), mark(tail(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__afterNth(mark(z0), mark(z1)))), x0, x1, tail(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(tail(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__take(mark(z0), mark(z1)))), x0, x1, tail(take(z0, z1))), A__SPLITAT(mark(x0), mark(tail(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(cons(mark(z0), z1))), x0, x1, tail(cons(z0, z1))), A__SPLITAT(mark(x0), mark(tail(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(s(mark(z0)))), x0, x1, tail(s(z0))), A__SPLITAT(mark(x0), mark(tail(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(pair(mark(z0), mark(z1)))), x0, x1, tail(pair(z0, z1))), A__SPLITAT(mark(x0), mark(tail(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(0)), x0, x1, tail(0)), A__SPLITAT(mark(x0), mark(tail(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(nil))) -> c7(A__U(a__splitAt(mark(x0), a__tail(nil)), x0, x1, tail(nil)), A__SPLITAT(mark(x0), mark(tail(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__tail(mark(x2))), natsFrom(z0), x1, tail(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(tail(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__tail(mark(x2))), fst(z0), x1, tail(x2)), A__SPLITAT(mark(fst(z0)), mark(tail(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__tail(mark(x2))), snd(z0), x1, tail(x2)), A__SPLITAT(mark(snd(z0)), mark(tail(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__tail(mark(x2))), splitAt(z0, z1), x1, tail(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(tail(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__tail(mark(x2))), u(z0, z1, z2, z3), x1, tail(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(tail(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__tail(mark(x2))), head(z0), x1, tail(x2)), A__SPLITAT(mark(head(z0)), mark(tail(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__tail(mark(x2))), tail(z0), x1, tail(x2)), A__SPLITAT(mark(tail(z0)), mark(tail(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__tail(mark(x2))), sel(z0, z1), x1, tail(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(tail(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__tail(mark(x2))), afterNth(z0, z1), x1, tail(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(tail(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__tail(mark(x2))), take(z0, z1), x1, tail(x2)), A__SPLITAT(mark(take(z0, z1)), mark(tail(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__tail(mark(x2))), cons(z0, z1), x1, tail(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(tail(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__tail(mark(x2))), s(z0), x1, tail(x2)), A__SPLITAT(mark(s(z0)), mark(tail(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__tail(mark(x2))), pair(z0, z1), x1, tail(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(tail(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(0, a__tail(mark(x2))), 0, x1, tail(x2)), A__SPLITAT(mark(0), mark(tail(x2))))
   A__SPLITAT(s(nil), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(nil, a__tail(mark(x2))), nil, x1, tail(x2)), A__SPLITAT(mark(nil), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(mark(x2)), mark(mark(x3))))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), sel(mark(x2), mark(x3))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__natsFrom(mark(z0)))), x0, x1, sel(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(sel(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__fst(mark(z0)))), x0, x1, sel(x2, fst(z0))), A__SPLITAT(mark(x0), mark(sel(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__snd(mark(z0)))), x0, x1, sel(x2, snd(z0))), A__SPLITAT(mark(x0), mark(sel(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, sel(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, sel(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(sel(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__head(mark(z0)))), x0, x1, sel(x2, head(z0))), A__SPLITAT(mark(x0), mark(sel(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__tail(mark(z0)))), x0, x1, sel(x2, tail(z0))), A__SPLITAT(mark(x0), mark(sel(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, sel(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, sel(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, sel(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), cons(mark(z0), z1))), x0, x1, sel(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), s(mark(z0)))), x0, x1, sel(x2, s(z0))), A__SPLITAT(mark(x0), mark(sel(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, sel(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), 0)), x0, x1, sel(x2, 0)), A__SPLITAT(mark(x0), mark(sel(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), nil)), x0, x1, sel(x2, nil)), A__SPLITAT(mark(x0), mark(sel(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__natsFrom(mark(z0)), mark(x3))), x0, x1, sel(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(sel(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__fst(mark(z0)), mark(x3))), x0, x1, sel(fst(z0), x3)), A__SPLITAT(mark(x0), mark(sel(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__snd(mark(z0)), mark(x3))), x0, x1, sel(snd(z0), x3)), A__SPLITAT(mark(x0), mark(sel(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, sel(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(sel(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__head(mark(z0)), mark(x3))), x0, x1, sel(head(z0), x3)), A__SPLITAT(mark(x0), mark(sel(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__tail(mark(z0)), mark(x3))), x0, x1, sel(tail(z0), x3)), A__SPLITAT(mark(x0), mark(sel(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(cons(mark(z0), z1), mark(x3))), x0, x1, sel(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(s(mark(z0)), mark(x3))), x0, x1, sel(s(z0), x3)), A__SPLITAT(mark(x0), mark(sel(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(0, mark(x3))), x0, x1, sel(0, x3)), A__SPLITAT(mark(x0), mark(sel(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(nil, mark(x3))), x0, x1, sel(nil, x3)), A__SPLITAT(mark(x0), mark(sel(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__sel(mark(x2), mark(x3))), natsFrom(z0), x1, sel(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(sel(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__sel(mark(x2), mark(x3))), fst(z0), x1, sel(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(sel(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__sel(mark(x2), mark(x3))), snd(z0), x1, sel(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(sel(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), splitAt(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(sel(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__sel(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, sel(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(sel(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__sel(mark(x2), mark(x3))), head(z0), x1, sel(x2, x3)), A__SPLITAT(mark(head(z0)), mark(sel(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__sel(mark(x2), mark(x3))), tail(z0), x1, sel(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(sel(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), sel(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(sel(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), afterNth(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(sel(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), take(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(sel(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__sel(mark(x2), mark(x3))), cons(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(sel(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__sel(mark(x2), mark(x3))), s(z0), x1, sel(x2, x3)), A__SPLITAT(mark(s(z0)), mark(sel(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), pair(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(sel(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(0, a__sel(mark(x2), mark(x3))), 0, x1, sel(x2, x3)), A__SPLITAT(mark(0), mark(sel(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(nil, a__sel(mark(x2), mark(x3))), nil, x1, sel(x2, x3)), A__SPLITAT(mark(nil), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(mark(x2)), mark(mark(x3))))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), afterNth(mark(x2), mark(x3))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__natsFrom(mark(z0)))), x0, x1, afterNth(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__fst(mark(z0)))), x0, x1, afterNth(x2, fst(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__snd(mark(z0)))), x0, x1, afterNth(x2, snd(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, afterNth(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, afterNth(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(afterNth(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__head(mark(z0)))), x0, x1, afterNth(x2, head(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__tail(mark(z0)))), x0, x1, afterNth(x2, tail(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, afterNth(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, afterNth(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, afterNth(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), cons(mark(z0), z1))), x0, x1, afterNth(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), s(mark(z0)))), x0, x1, afterNth(x2, s(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, afterNth(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), 0)), x0, x1, afterNth(x2, 0)), A__SPLITAT(mark(x0), mark(afterNth(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), nil)), x0, x1, afterNth(x2, nil)), A__SPLITAT(mark(x0), mark(afterNth(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__natsFrom(mark(z0)), mark(x3))), x0, x1, afterNth(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__fst(mark(z0)), mark(x3))), x0, x1, afterNth(fst(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__snd(mark(z0)), mark(x3))), x0, x1, afterNth(snd(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, afterNth(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(afterNth(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__head(mark(z0)), mark(x3))), x0, x1, afterNth(head(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__tail(mark(z0)), mark(x3))), x0, x1, afterNth(tail(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(cons(mark(z0), z1), mark(x3))), x0, x1, afterNth(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(s(mark(z0)), mark(x3))), x0, x1, afterNth(s(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(0, mark(x3))), x0, x1, afterNth(0, x3)), A__SPLITAT(mark(x0), mark(afterNth(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(nil, mark(x3))), x0, x1, afterNth(nil, x3)), A__SPLITAT(mark(x0), mark(afterNth(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__afterNth(mark(x2), mark(x3))), natsFrom(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(afterNth(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__afterNth(mark(x2), mark(x3))), fst(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(afterNth(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__afterNth(mark(x2), mark(x3))), snd(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(afterNth(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), splitAt(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(afterNth(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__afterNth(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, afterNth(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(afterNth(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__afterNth(mark(x2), mark(x3))), head(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(head(z0)), mark(afterNth(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__afterNth(mark(x2), mark(x3))), tail(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(afterNth(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), sel(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(afterNth(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), afterNth(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(afterNth(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), take(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(afterNth(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__afterNth(mark(x2), mark(x3))), cons(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(afterNth(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__afterNth(mark(x2), mark(x3))), s(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(s(z0)), mark(afterNth(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), pair(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(afterNth(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(afterNth(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(0, a__afterNth(mark(x2), mark(x3))), 0, x1, afterNth(x2, x3)), A__SPLITAT(mark(0), mark(afterNth(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(nil, a__afterNth(mark(x2), mark(x3))), nil, x1, afterNth(x2, x3)), A__SPLITAT(mark(nil), mark(afterNth(x2, x3))))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(mark(x0), head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__natsFrom(mark(z0)))), x0, x1, head(natsFrom(z0))), A__SPLITAT(mark(x0), mark(head(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__fst(mark(z0)))), x0, x1, head(fst(z0))), A__SPLITAT(mark(x0), mark(head(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__snd(mark(z0)))), x0, x1, head(snd(z0))), A__SPLITAT(mark(x0), mark(head(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__splitAt(mark(z0), mark(z1)))), x0, x1, head(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(head(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__u(mark(z0), z1, z2, z3))), x0, x1, head(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(head(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__head(mark(z0)))), x0, x1, head(head(z0))), A__SPLITAT(mark(x0), mark(head(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__tail(mark(z0)))), x0, x1, head(tail(z0))), A__SPLITAT(mark(x0), mark(head(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__sel(mark(z0), mark(z1)))), x0, x1, head(sel(z0, z1))), A__SPLITAT(mark(x0), mark(head(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(z0), mark(z1)))), x0, x1, head(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(head(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__take(mark(z0), mark(z1)))), x0, x1, head(take(z0, z1))), A__SPLITAT(mark(x0), mark(head(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(cons(mark(z0), z1))), x0, x1, head(cons(z0, z1))), A__SPLITAT(mark(x0), mark(head(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(s(mark(z0)))), x0, x1, head(s(z0))), A__SPLITAT(mark(x0), mark(head(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(pair(mark(z0), mark(z1)))), x0, x1, head(pair(z0, z1))), A__SPLITAT(mark(x0), mark(head(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(0))) -> c7(A__U(a__splitAt(mark(x0), a__head(0)), x0, x1, head(0)), A__SPLITAT(mark(x0), mark(head(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(nil))) -> c7(A__U(a__splitAt(mark(x0), a__head(nil)), x0, x1, head(nil)), A__SPLITAT(mark(x0), mark(head(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__head(mark(x2))), natsFrom(z0), x1, head(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(head(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__head(mark(x2))), fst(z0), x1, head(x2)), A__SPLITAT(mark(fst(z0)), mark(head(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__head(mark(x2))), snd(z0), x1, head(x2)), A__SPLITAT(mark(snd(z0)), mark(head(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__head(mark(x2))), splitAt(z0, z1), x1, head(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(head(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__head(mark(x2))), u(z0, z1, z2, z3), x1, head(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(head(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__head(mark(x2))), head(z0), x1, head(x2)), A__SPLITAT(mark(head(z0)), mark(head(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__head(mark(x2))), tail(z0), x1, head(x2)), A__SPLITAT(mark(tail(z0)), mark(head(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__head(mark(x2))), sel(z0, z1), x1, head(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(head(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__head(mark(x2))), afterNth(z0, z1), x1, head(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(head(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__head(mark(x2))), take(z0, z1), x1, head(x2)), A__SPLITAT(mark(take(z0, z1)), mark(head(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__head(mark(x2))), cons(z0, z1), x1, head(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(head(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__head(mark(x2))), s(z0), x1, head(x2)), A__SPLITAT(mark(s(z0)), mark(head(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__head(mark(x2))), pair(z0, z1), x1, head(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(head(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(0, a__head(mark(x2))), 0, x1, head(x2)), A__SPLITAT(mark(0), mark(head(x2))))
   A__SPLITAT(s(nil), cons(x1, head(x2))) -> c7(A__U(a__splitAt(nil, a__head(mark(x2))), nil, x1, head(x2)), A__SPLITAT(mark(nil), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(mark(x0), tail(mark(x2))), x0, x1, tail(x2)), A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__natsFrom(mark(z0)))), x0, x1, tail(natsFrom(z0))), A__SPLITAT(mark(x0), mark(tail(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__fst(mark(z0)))), x0, x1, tail(fst(z0))), A__SPLITAT(mark(x0), mark(tail(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__snd(mark(z0)))), x0, x1, tail(snd(z0))), A__SPLITAT(mark(x0), mark(tail(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__splitAt(mark(z0), mark(z1)))), x0, x1, tail(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(tail(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__u(mark(z0), z1, z2, z3))), x0, x1, tail(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(tail(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__head(mark(z0)))), x0, x1, tail(head(z0))), A__SPLITAT(mark(x0), mark(tail(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__tail(mark(z0)))), x0, x1, tail(tail(z0))), A__SPLITAT(mark(x0), mark(tail(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__sel(mark(z0), mark(z1)))), x0, x1, tail(sel(z0, z1))), A__SPLITAT(mark(x0), mark(tail(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__afterNth(mark(z0), mark(z1)))), x0, x1, tail(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(tail(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__take(mark(z0), mark(z1)))), x0, x1, tail(take(z0, z1))), A__SPLITAT(mark(x0), mark(tail(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(cons(mark(z0), z1))), x0, x1, tail(cons(z0, z1))), A__SPLITAT(mark(x0), mark(tail(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(s(mark(z0)))), x0, x1, tail(s(z0))), A__SPLITAT(mark(x0), mark(tail(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(pair(mark(z0), mark(z1)))), x0, x1, tail(pair(z0, z1))), A__SPLITAT(mark(x0), mark(tail(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(0)), x0, x1, tail(0)), A__SPLITAT(mark(x0), mark(tail(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(nil))) -> c7(A__U(a__splitAt(mark(x0), a__tail(nil)), x0, x1, tail(nil)), A__SPLITAT(mark(x0), mark(tail(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__tail(mark(x2))), natsFrom(z0), x1, tail(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(tail(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__tail(mark(x2))), fst(z0), x1, tail(x2)), A__SPLITAT(mark(fst(z0)), mark(tail(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__tail(mark(x2))), snd(z0), x1, tail(x2)), A__SPLITAT(mark(snd(z0)), mark(tail(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__tail(mark(x2))), splitAt(z0, z1), x1, tail(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(tail(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__tail(mark(x2))), u(z0, z1, z2, z3), x1, tail(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(tail(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__tail(mark(x2))), head(z0), x1, tail(x2)), A__SPLITAT(mark(head(z0)), mark(tail(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__tail(mark(x2))), tail(z0), x1, tail(x2)), A__SPLITAT(mark(tail(z0)), mark(tail(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__tail(mark(x2))), sel(z0, z1), x1, tail(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(tail(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__tail(mark(x2))), afterNth(z0, z1), x1, tail(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(tail(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__tail(mark(x2))), take(z0, z1), x1, tail(x2)), A__SPLITAT(mark(take(z0, z1)), mark(tail(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__tail(mark(x2))), cons(z0, z1), x1, tail(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(tail(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__tail(mark(x2))), s(z0), x1, tail(x2)), A__SPLITAT(mark(s(z0)), mark(tail(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__tail(mark(x2))), pair(z0, z1), x1, tail(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(tail(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(0, a__tail(mark(x2))), 0, x1, tail(x2)), A__SPLITAT(mark(0), mark(tail(x2))))
   A__SPLITAT(s(nil), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(nil, a__tail(mark(x2))), nil, x1, tail(x2)), A__SPLITAT(mark(nil), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(mark(x2)), mark(mark(x3))))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), sel(mark(x2), mark(x3))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__natsFrom(mark(z0)))), x0, x1, sel(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(sel(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__fst(mark(z0)))), x0, x1, sel(x2, fst(z0))), A__SPLITAT(mark(x0), mark(sel(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__snd(mark(z0)))), x0, x1, sel(x2, snd(z0))), A__SPLITAT(mark(x0), mark(sel(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, sel(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, sel(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(sel(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__head(mark(z0)))), x0, x1, sel(x2, head(z0))), A__SPLITAT(mark(x0), mark(sel(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__tail(mark(z0)))), x0, x1, sel(x2, tail(z0))), A__SPLITAT(mark(x0), mark(sel(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, sel(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, sel(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, sel(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), cons(mark(z0), z1))), x0, x1, sel(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), s(mark(z0)))), x0, x1, sel(x2, s(z0))), A__SPLITAT(mark(x0), mark(sel(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, sel(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), 0)), x0, x1, sel(x2, 0)), A__SPLITAT(mark(x0), mark(sel(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), nil)), x0, x1, sel(x2, nil)), A__SPLITAT(mark(x0), mark(sel(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__natsFrom(mark(z0)), mark(x3))), x0, x1, sel(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(sel(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__fst(mark(z0)), mark(x3))), x0, x1, sel(fst(z0), x3)), A__SPLITAT(mark(x0), mark(sel(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__snd(mark(z0)), mark(x3))), x0, x1, sel(snd(z0), x3)), A__SPLITAT(mark(x0), mark(sel(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, sel(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(sel(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__head(mark(z0)), mark(x3))), x0, x1, sel(head(z0), x3)), A__SPLITAT(mark(x0), mark(sel(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__tail(mark(z0)), mark(x3))), x0, x1, sel(tail(z0), x3)), A__SPLITAT(mark(x0), mark(sel(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(cons(mark(z0), z1), mark(x3))), x0, x1, sel(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(s(mark(z0)), mark(x3))), x0, x1, sel(s(z0), x3)), A__SPLITAT(mark(x0), mark(sel(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(0, mark(x3))), x0, x1, sel(0, x3)), A__SPLITAT(mark(x0), mark(sel(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(nil, mark(x3))), x0, x1, sel(nil, x3)), A__SPLITAT(mark(x0), mark(sel(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__sel(mark(x2), mark(x3))), natsFrom(z0), x1, sel(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(sel(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__sel(mark(x2), mark(x3))), fst(z0), x1, sel(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(sel(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__sel(mark(x2), mark(x3))), snd(z0), x1, sel(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(sel(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), splitAt(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(sel(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__sel(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, sel(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(sel(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__sel(mark(x2), mark(x3))), head(z0), x1, sel(x2, x3)), A__SPLITAT(mark(head(z0)), mark(sel(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__sel(mark(x2), mark(x3))), tail(z0), x1, sel(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(sel(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), sel(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(sel(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), afterNth(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(sel(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), take(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(sel(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__sel(mark(x2), mark(x3))), cons(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(sel(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__sel(mark(x2), mark(x3))), s(z0), x1, sel(x2, x3)), A__SPLITAT(mark(s(z0)), mark(sel(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), pair(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(sel(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(0, a__sel(mark(x2), mark(x3))), 0, x1, sel(x2, x3)), A__SPLITAT(mark(0), mark(sel(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(nil, a__sel(mark(x2), mark(x3))), nil, x1, sel(x2, x3)), A__SPLITAT(mark(nil), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(mark(x2)), mark(mark(x3))))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), afterNth(mark(x2), mark(x3))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__natsFrom(mark(z0)))), x0, x1, afterNth(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__fst(mark(z0)))), x0, x1, afterNth(x2, fst(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__snd(mark(z0)))), x0, x1, afterNth(x2, snd(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, afterNth(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, afterNth(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(afterNth(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__head(mark(z0)))), x0, x1, afterNth(x2, head(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__tail(mark(z0)))), x0, x1, afterNth(x2, tail(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, afterNth(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, afterNth(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, afterNth(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), cons(mark(z0), z1))), x0, x1, afterNth(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), s(mark(z0)))), x0, x1, afterNth(x2, s(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, afterNth(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), 0)), x0, x1, afterNth(x2, 0)), A__SPLITAT(mark(x0), mark(afterNth(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), nil)), x0, x1, afterNth(x2, nil)), A__SPLITAT(mark(x0), mark(afterNth(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__natsFrom(mark(z0)), mark(x3))), x0, x1, afterNth(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__fst(mark(z0)), mark(x3))), x0, x1, afterNth(fst(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__snd(mark(z0)), mark(x3))), x0, x1, afterNth(snd(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, afterNth(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(afterNth(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__head(mark(z0)), mark(x3))), x0, x1, afterNth(head(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__tail(mark(z0)), mark(x3))), x0, x1, afterNth(tail(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(cons(mark(z0), z1), mark(x3))), x0, x1, afterNth(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(s(mark(z0)), mark(x3))), x0, x1, afterNth(s(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(0, mark(x3))), x0, x1, afterNth(0, x3)), A__SPLITAT(mark(x0), mark(afterNth(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(nil, mark(x3))), x0, x1, afterNth(nil, x3)), A__SPLITAT(mark(x0), mark(afterNth(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__afterNth(mark(x2), mark(x3))), natsFrom(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(afterNth(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__afterNth(mark(x2), mark(x3))), fst(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(afterNth(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__afterNth(mark(x2), mark(x3))), snd(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(afterNth(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), splitAt(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(afterNth(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__afterNth(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, afterNth(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(afterNth(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__afterNth(mark(x2), mark(x3))), head(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(head(z0)), mark(afterNth(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__afterNth(mark(x2), mark(x3))), tail(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(afterNth(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), sel(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(afterNth(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), afterNth(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(afterNth(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), take(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(afterNth(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__afterNth(mark(x2), mark(x3))), cons(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(afterNth(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__afterNth(mark(x2), mark(x3))), s(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(s(z0)), mark(afterNth(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), pair(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(afterNth(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(afterNth(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(0, a__afterNth(mark(x2), mark(x3))), 0, x1, afterNth(x2, x3)), A__SPLITAT(mark(0), mark(afterNth(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(nil, a__afterNth(mark(x2), mark(x3))), nil, x1, afterNth(x2, x3)), A__SPLITAT(mark(nil), mark(afterNth(x2, x3))))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1, c33_2, c33_1, c7_1


----------------------------------------

(161) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0)) by 
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__U(splitAt(mark(x0), a__take(mark(x2), mark(x3))), x0, x1, take(x2, x3)), A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(mark(x2)), mark(mark(x3))))), x0, x1, take(x2, x3)), A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), take(mark(x2), mark(x3))), x0, x1, take(x2, x3)), A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__natsFrom(mark(z0)))), x0, x1, take(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(take(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__fst(mark(z0)))), x0, x1, take(x2, fst(z0))), A__SPLITAT(mark(x0), mark(take(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__snd(mark(z0)))), x0, x1, take(x2, snd(z0))), A__SPLITAT(mark(x0), mark(take(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, take(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, take(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(take(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__head(mark(z0)))), x0, x1, take(x2, head(z0))), A__SPLITAT(mark(x0), mark(take(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__tail(mark(z0)))), x0, x1, take(x2, tail(z0))), A__SPLITAT(mark(x0), mark(take(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, take(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, take(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, take(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), cons(mark(z0), z1))), x0, x1, take(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), s(mark(z0)))), x0, x1, take(x2, s(z0))), A__SPLITAT(mark(x0), mark(take(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, take(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), 0)), x0, x1, take(x2, 0)), A__SPLITAT(mark(x0), mark(take(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), nil)), x0, x1, take(x2, nil)), A__SPLITAT(mark(x0), mark(take(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__natsFrom(mark(z0)), mark(x3))), x0, x1, take(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(take(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__fst(mark(z0)), mark(x3))), x0, x1, take(fst(z0), x3)), A__SPLITAT(mark(x0), mark(take(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__snd(mark(z0)), mark(x3))), x0, x1, take(snd(z0), x3)), A__SPLITAT(mark(x0), mark(take(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, take(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, take(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(take(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__head(mark(z0)), mark(x3))), x0, x1, take(head(z0), x3)), A__SPLITAT(mark(x0), mark(take(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__tail(mark(z0)), mark(x3))), x0, x1, take(tail(z0), x3)), A__SPLITAT(mark(x0), mark(take(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, take(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, take(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, take(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(cons(mark(z0), z1), mark(x3))), x0, x1, take(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(s(mark(z0)), mark(x3))), x0, x1, take(s(z0), x3)), A__SPLITAT(mark(x0), mark(take(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, take(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(0, mark(x3))), x0, x1, take(0, x3)), A__SPLITAT(mark(x0), mark(take(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(nil, mark(x3))), x0, x1, take(nil, x3)), A__SPLITAT(mark(x0), mark(take(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__take(mark(x2), mark(x3))), natsFrom(z0), x1, take(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(take(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__take(mark(x2), mark(x3))), fst(z0), x1, take(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(take(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__take(mark(x2), mark(x3))), snd(z0), x1, take(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(take(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), splitAt(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(take(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__take(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, take(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(take(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__take(mark(x2), mark(x3))), head(z0), x1, take(x2, x3)), A__SPLITAT(mark(head(z0)), mark(take(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__take(mark(x2), mark(x3))), tail(z0), x1, take(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(take(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), sel(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(take(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), afterNth(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(take(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), take(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(take(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__take(mark(x2), mark(x3))), cons(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(take(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__take(mark(x2), mark(x3))), s(z0), x1, take(x2, x3)), A__SPLITAT(mark(s(z0)), mark(take(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), pair(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(take(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(0, a__take(mark(x2), mark(x3))), 0, x1, take(x2, x3)), A__SPLITAT(mark(0), mark(take(x2, x3))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(nil, a__take(mark(x2), mark(x3))), nil, x1, take(x2, x3)), A__SPLITAT(mark(nil), mark(take(x2, x3))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(take(x2, x3))))

----------------------------------------

(162)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(mark(x0), head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__natsFrom(mark(z0)))), x0, x1, head(natsFrom(z0))), A__SPLITAT(mark(x0), mark(head(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__fst(mark(z0)))), x0, x1, head(fst(z0))), A__SPLITAT(mark(x0), mark(head(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__snd(mark(z0)))), x0, x1, head(snd(z0))), A__SPLITAT(mark(x0), mark(head(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__splitAt(mark(z0), mark(z1)))), x0, x1, head(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(head(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__u(mark(z0), z1, z2, z3))), x0, x1, head(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(head(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__head(mark(z0)))), x0, x1, head(head(z0))), A__SPLITAT(mark(x0), mark(head(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__tail(mark(z0)))), x0, x1, head(tail(z0))), A__SPLITAT(mark(x0), mark(head(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__sel(mark(z0), mark(z1)))), x0, x1, head(sel(z0, z1))), A__SPLITAT(mark(x0), mark(head(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(z0), mark(z1)))), x0, x1, head(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(head(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__take(mark(z0), mark(z1)))), x0, x1, head(take(z0, z1))), A__SPLITAT(mark(x0), mark(head(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(cons(mark(z0), z1))), x0, x1, head(cons(z0, z1))), A__SPLITAT(mark(x0), mark(head(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(s(mark(z0)))), x0, x1, head(s(z0))), A__SPLITAT(mark(x0), mark(head(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(pair(mark(z0), mark(z1)))), x0, x1, head(pair(z0, z1))), A__SPLITAT(mark(x0), mark(head(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(0))) -> c7(A__U(a__splitAt(mark(x0), a__head(0)), x0, x1, head(0)), A__SPLITAT(mark(x0), mark(head(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(nil))) -> c7(A__U(a__splitAt(mark(x0), a__head(nil)), x0, x1, head(nil)), A__SPLITAT(mark(x0), mark(head(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__head(mark(x2))), natsFrom(z0), x1, head(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(head(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__head(mark(x2))), fst(z0), x1, head(x2)), A__SPLITAT(mark(fst(z0)), mark(head(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__head(mark(x2))), snd(z0), x1, head(x2)), A__SPLITAT(mark(snd(z0)), mark(head(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__head(mark(x2))), splitAt(z0, z1), x1, head(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(head(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__head(mark(x2))), u(z0, z1, z2, z3), x1, head(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(head(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__head(mark(x2))), head(z0), x1, head(x2)), A__SPLITAT(mark(head(z0)), mark(head(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__head(mark(x2))), tail(z0), x1, head(x2)), A__SPLITAT(mark(tail(z0)), mark(head(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__head(mark(x2))), sel(z0, z1), x1, head(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(head(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__head(mark(x2))), afterNth(z0, z1), x1, head(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(head(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__head(mark(x2))), take(z0, z1), x1, head(x2)), A__SPLITAT(mark(take(z0, z1)), mark(head(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__head(mark(x2))), cons(z0, z1), x1, head(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(head(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__head(mark(x2))), s(z0), x1, head(x2)), A__SPLITAT(mark(s(z0)), mark(head(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__head(mark(x2))), pair(z0, z1), x1, head(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(head(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(0, a__head(mark(x2))), 0, x1, head(x2)), A__SPLITAT(mark(0), mark(head(x2))))
   A__SPLITAT(s(nil), cons(x1, head(x2))) -> c7(A__U(a__splitAt(nil, a__head(mark(x2))), nil, x1, head(x2)), A__SPLITAT(mark(nil), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(mark(x0), tail(mark(x2))), x0, x1, tail(x2)), A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__natsFrom(mark(z0)))), x0, x1, tail(natsFrom(z0))), A__SPLITAT(mark(x0), mark(tail(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__fst(mark(z0)))), x0, x1, tail(fst(z0))), A__SPLITAT(mark(x0), mark(tail(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__snd(mark(z0)))), x0, x1, tail(snd(z0))), A__SPLITAT(mark(x0), mark(tail(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__splitAt(mark(z0), mark(z1)))), x0, x1, tail(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(tail(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__u(mark(z0), z1, z2, z3))), x0, x1, tail(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(tail(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__head(mark(z0)))), x0, x1, tail(head(z0))), A__SPLITAT(mark(x0), mark(tail(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__tail(mark(z0)))), x0, x1, tail(tail(z0))), A__SPLITAT(mark(x0), mark(tail(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__sel(mark(z0), mark(z1)))), x0, x1, tail(sel(z0, z1))), A__SPLITAT(mark(x0), mark(tail(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__afterNth(mark(z0), mark(z1)))), x0, x1, tail(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(tail(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__take(mark(z0), mark(z1)))), x0, x1, tail(take(z0, z1))), A__SPLITAT(mark(x0), mark(tail(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(cons(mark(z0), z1))), x0, x1, tail(cons(z0, z1))), A__SPLITAT(mark(x0), mark(tail(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(s(mark(z0)))), x0, x1, tail(s(z0))), A__SPLITAT(mark(x0), mark(tail(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(pair(mark(z0), mark(z1)))), x0, x1, tail(pair(z0, z1))), A__SPLITAT(mark(x0), mark(tail(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(0)), x0, x1, tail(0)), A__SPLITAT(mark(x0), mark(tail(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(nil))) -> c7(A__U(a__splitAt(mark(x0), a__tail(nil)), x0, x1, tail(nil)), A__SPLITAT(mark(x0), mark(tail(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__tail(mark(x2))), natsFrom(z0), x1, tail(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(tail(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__tail(mark(x2))), fst(z0), x1, tail(x2)), A__SPLITAT(mark(fst(z0)), mark(tail(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__tail(mark(x2))), snd(z0), x1, tail(x2)), A__SPLITAT(mark(snd(z0)), mark(tail(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__tail(mark(x2))), splitAt(z0, z1), x1, tail(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(tail(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__tail(mark(x2))), u(z0, z1, z2, z3), x1, tail(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(tail(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__tail(mark(x2))), head(z0), x1, tail(x2)), A__SPLITAT(mark(head(z0)), mark(tail(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__tail(mark(x2))), tail(z0), x1, tail(x2)), A__SPLITAT(mark(tail(z0)), mark(tail(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__tail(mark(x2))), sel(z0, z1), x1, tail(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(tail(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__tail(mark(x2))), afterNth(z0, z1), x1, tail(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(tail(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__tail(mark(x2))), take(z0, z1), x1, tail(x2)), A__SPLITAT(mark(take(z0, z1)), mark(tail(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__tail(mark(x2))), cons(z0, z1), x1, tail(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(tail(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__tail(mark(x2))), s(z0), x1, tail(x2)), A__SPLITAT(mark(s(z0)), mark(tail(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__tail(mark(x2))), pair(z0, z1), x1, tail(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(tail(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(0, a__tail(mark(x2))), 0, x1, tail(x2)), A__SPLITAT(mark(0), mark(tail(x2))))
   A__SPLITAT(s(nil), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(nil, a__tail(mark(x2))), nil, x1, tail(x2)), A__SPLITAT(mark(nil), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(mark(x2)), mark(mark(x3))))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), sel(mark(x2), mark(x3))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__natsFrom(mark(z0)))), x0, x1, sel(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(sel(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__fst(mark(z0)))), x0, x1, sel(x2, fst(z0))), A__SPLITAT(mark(x0), mark(sel(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__snd(mark(z0)))), x0, x1, sel(x2, snd(z0))), A__SPLITAT(mark(x0), mark(sel(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, sel(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, sel(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(sel(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__head(mark(z0)))), x0, x1, sel(x2, head(z0))), A__SPLITAT(mark(x0), mark(sel(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__tail(mark(z0)))), x0, x1, sel(x2, tail(z0))), A__SPLITAT(mark(x0), mark(sel(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, sel(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, sel(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, sel(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), cons(mark(z0), z1))), x0, x1, sel(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), s(mark(z0)))), x0, x1, sel(x2, s(z0))), A__SPLITAT(mark(x0), mark(sel(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, sel(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), 0)), x0, x1, sel(x2, 0)), A__SPLITAT(mark(x0), mark(sel(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), nil)), x0, x1, sel(x2, nil)), A__SPLITAT(mark(x0), mark(sel(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__natsFrom(mark(z0)), mark(x3))), x0, x1, sel(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(sel(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__fst(mark(z0)), mark(x3))), x0, x1, sel(fst(z0), x3)), A__SPLITAT(mark(x0), mark(sel(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__snd(mark(z0)), mark(x3))), x0, x1, sel(snd(z0), x3)), A__SPLITAT(mark(x0), mark(sel(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, sel(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(sel(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__head(mark(z0)), mark(x3))), x0, x1, sel(head(z0), x3)), A__SPLITAT(mark(x0), mark(sel(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__tail(mark(z0)), mark(x3))), x0, x1, sel(tail(z0), x3)), A__SPLITAT(mark(x0), mark(sel(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(cons(mark(z0), z1), mark(x3))), x0, x1, sel(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(s(mark(z0)), mark(x3))), x0, x1, sel(s(z0), x3)), A__SPLITAT(mark(x0), mark(sel(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(0, mark(x3))), x0, x1, sel(0, x3)), A__SPLITAT(mark(x0), mark(sel(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(nil, mark(x3))), x0, x1, sel(nil, x3)), A__SPLITAT(mark(x0), mark(sel(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__sel(mark(x2), mark(x3))), natsFrom(z0), x1, sel(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(sel(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__sel(mark(x2), mark(x3))), fst(z0), x1, sel(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(sel(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__sel(mark(x2), mark(x3))), snd(z0), x1, sel(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(sel(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), splitAt(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(sel(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__sel(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, sel(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(sel(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__sel(mark(x2), mark(x3))), head(z0), x1, sel(x2, x3)), A__SPLITAT(mark(head(z0)), mark(sel(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__sel(mark(x2), mark(x3))), tail(z0), x1, sel(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(sel(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), sel(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(sel(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), afterNth(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(sel(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), take(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(sel(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__sel(mark(x2), mark(x3))), cons(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(sel(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__sel(mark(x2), mark(x3))), s(z0), x1, sel(x2, x3)), A__SPLITAT(mark(s(z0)), mark(sel(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), pair(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(sel(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(0, a__sel(mark(x2), mark(x3))), 0, x1, sel(x2, x3)), A__SPLITAT(mark(0), mark(sel(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(nil, a__sel(mark(x2), mark(x3))), nil, x1, sel(x2, x3)), A__SPLITAT(mark(nil), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(mark(x2)), mark(mark(x3))))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), afterNth(mark(x2), mark(x3))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__natsFrom(mark(z0)))), x0, x1, afterNth(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__fst(mark(z0)))), x0, x1, afterNth(x2, fst(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__snd(mark(z0)))), x0, x1, afterNth(x2, snd(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, afterNth(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, afterNth(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(afterNth(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__head(mark(z0)))), x0, x1, afterNth(x2, head(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__tail(mark(z0)))), x0, x1, afterNth(x2, tail(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, afterNth(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, afterNth(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, afterNth(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), cons(mark(z0), z1))), x0, x1, afterNth(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), s(mark(z0)))), x0, x1, afterNth(x2, s(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, afterNth(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), 0)), x0, x1, afterNth(x2, 0)), A__SPLITAT(mark(x0), mark(afterNth(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), nil)), x0, x1, afterNth(x2, nil)), A__SPLITAT(mark(x0), mark(afterNth(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__natsFrom(mark(z0)), mark(x3))), x0, x1, afterNth(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__fst(mark(z0)), mark(x3))), x0, x1, afterNth(fst(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__snd(mark(z0)), mark(x3))), x0, x1, afterNth(snd(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, afterNth(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(afterNth(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__head(mark(z0)), mark(x3))), x0, x1, afterNth(head(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__tail(mark(z0)), mark(x3))), x0, x1, afterNth(tail(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(cons(mark(z0), z1), mark(x3))), x0, x1, afterNth(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(s(mark(z0)), mark(x3))), x0, x1, afterNth(s(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(0, mark(x3))), x0, x1, afterNth(0, x3)), A__SPLITAT(mark(x0), mark(afterNth(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(nil, mark(x3))), x0, x1, afterNth(nil, x3)), A__SPLITAT(mark(x0), mark(afterNth(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__afterNth(mark(x2), mark(x3))), natsFrom(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(afterNth(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__afterNth(mark(x2), mark(x3))), fst(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(afterNth(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__afterNth(mark(x2), mark(x3))), snd(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(afterNth(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), splitAt(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(afterNth(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__afterNth(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, afterNth(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(afterNth(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__afterNth(mark(x2), mark(x3))), head(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(head(z0)), mark(afterNth(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__afterNth(mark(x2), mark(x3))), tail(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(afterNth(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), sel(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(afterNth(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), afterNth(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(afterNth(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), take(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(afterNth(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__afterNth(mark(x2), mark(x3))), cons(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(afterNth(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__afterNth(mark(x2), mark(x3))), s(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(s(z0)), mark(afterNth(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), pair(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(afterNth(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(afterNth(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(0, a__afterNth(mark(x2), mark(x3))), 0, x1, afterNth(x2, x3)), A__SPLITAT(mark(0), mark(afterNth(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(nil, a__afterNth(mark(x2), mark(x3))), nil, x1, afterNth(x2, x3)), A__SPLITAT(mark(nil), mark(afterNth(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__U(splitAt(mark(x0), a__take(mark(x2), mark(x3))), x0, x1, take(x2, x3)), A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(mark(x2)), mark(mark(x3))))), x0, x1, take(x2, x3)), A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), take(mark(x2), mark(x3))), x0, x1, take(x2, x3)), A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__natsFrom(mark(z0)))), x0, x1, take(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(take(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__fst(mark(z0)))), x0, x1, take(x2, fst(z0))), A__SPLITAT(mark(x0), mark(take(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__snd(mark(z0)))), x0, x1, take(x2, snd(z0))), A__SPLITAT(mark(x0), mark(take(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, take(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, take(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(take(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__head(mark(z0)))), x0, x1, take(x2, head(z0))), A__SPLITAT(mark(x0), mark(take(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__tail(mark(z0)))), x0, x1, take(x2, tail(z0))), A__SPLITAT(mark(x0), mark(take(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, take(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, take(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, take(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), cons(mark(z0), z1))), x0, x1, take(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), s(mark(z0)))), x0, x1, take(x2, s(z0))), A__SPLITAT(mark(x0), mark(take(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, take(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), 0)), x0, x1, take(x2, 0)), A__SPLITAT(mark(x0), mark(take(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), nil)), x0, x1, take(x2, nil)), A__SPLITAT(mark(x0), mark(take(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__natsFrom(mark(z0)), mark(x3))), x0, x1, take(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(take(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__fst(mark(z0)), mark(x3))), x0, x1, take(fst(z0), x3)), A__SPLITAT(mark(x0), mark(take(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__snd(mark(z0)), mark(x3))), x0, x1, take(snd(z0), x3)), A__SPLITAT(mark(x0), mark(take(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, take(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, take(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(take(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__head(mark(z0)), mark(x3))), x0, x1, take(head(z0), x3)), A__SPLITAT(mark(x0), mark(take(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__tail(mark(z0)), mark(x3))), x0, x1, take(tail(z0), x3)), A__SPLITAT(mark(x0), mark(take(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, take(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, take(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, take(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(cons(mark(z0), z1), mark(x3))), x0, x1, take(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(s(mark(z0)), mark(x3))), x0, x1, take(s(z0), x3)), A__SPLITAT(mark(x0), mark(take(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, take(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(0, mark(x3))), x0, x1, take(0, x3)), A__SPLITAT(mark(x0), mark(take(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(nil, mark(x3))), x0, x1, take(nil, x3)), A__SPLITAT(mark(x0), mark(take(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__take(mark(x2), mark(x3))), natsFrom(z0), x1, take(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(take(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__take(mark(x2), mark(x3))), fst(z0), x1, take(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(take(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__take(mark(x2), mark(x3))), snd(z0), x1, take(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(take(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), splitAt(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(take(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__take(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, take(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(take(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__take(mark(x2), mark(x3))), head(z0), x1, take(x2, x3)), A__SPLITAT(mark(head(z0)), mark(take(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__take(mark(x2), mark(x3))), tail(z0), x1, take(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(take(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), sel(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(take(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), afterNth(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(take(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), take(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(take(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__take(mark(x2), mark(x3))), cons(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(take(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__take(mark(x2), mark(x3))), s(z0), x1, take(x2, x3)), A__SPLITAT(mark(s(z0)), mark(take(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), pair(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(take(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(0, a__take(mark(x2), mark(x3))), 0, x1, take(x2, x3)), A__SPLITAT(mark(0), mark(take(x2, x3))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(nil, a__take(mark(x2), mark(x3))), nil, x1, take(x2, x3)), A__SPLITAT(mark(nil), mark(take(x2, x3))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(take(x2, x3))))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(mark(x0), head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__natsFrom(mark(z0)))), x0, x1, head(natsFrom(z0))), A__SPLITAT(mark(x0), mark(head(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__fst(mark(z0)))), x0, x1, head(fst(z0))), A__SPLITAT(mark(x0), mark(head(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__snd(mark(z0)))), x0, x1, head(snd(z0))), A__SPLITAT(mark(x0), mark(head(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__splitAt(mark(z0), mark(z1)))), x0, x1, head(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(head(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__u(mark(z0), z1, z2, z3))), x0, x1, head(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(head(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__head(mark(z0)))), x0, x1, head(head(z0))), A__SPLITAT(mark(x0), mark(head(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__tail(mark(z0)))), x0, x1, head(tail(z0))), A__SPLITAT(mark(x0), mark(head(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__sel(mark(z0), mark(z1)))), x0, x1, head(sel(z0, z1))), A__SPLITAT(mark(x0), mark(head(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(z0), mark(z1)))), x0, x1, head(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(head(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__take(mark(z0), mark(z1)))), x0, x1, head(take(z0, z1))), A__SPLITAT(mark(x0), mark(head(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(cons(mark(z0), z1))), x0, x1, head(cons(z0, z1))), A__SPLITAT(mark(x0), mark(head(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(s(mark(z0)))), x0, x1, head(s(z0))), A__SPLITAT(mark(x0), mark(head(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(pair(mark(z0), mark(z1)))), x0, x1, head(pair(z0, z1))), A__SPLITAT(mark(x0), mark(head(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(0))) -> c7(A__U(a__splitAt(mark(x0), a__head(0)), x0, x1, head(0)), A__SPLITAT(mark(x0), mark(head(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(nil))) -> c7(A__U(a__splitAt(mark(x0), a__head(nil)), x0, x1, head(nil)), A__SPLITAT(mark(x0), mark(head(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__head(mark(x2))), natsFrom(z0), x1, head(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(head(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__head(mark(x2))), fst(z0), x1, head(x2)), A__SPLITAT(mark(fst(z0)), mark(head(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__head(mark(x2))), snd(z0), x1, head(x2)), A__SPLITAT(mark(snd(z0)), mark(head(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__head(mark(x2))), splitAt(z0, z1), x1, head(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(head(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__head(mark(x2))), u(z0, z1, z2, z3), x1, head(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(head(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__head(mark(x2))), head(z0), x1, head(x2)), A__SPLITAT(mark(head(z0)), mark(head(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__head(mark(x2))), tail(z0), x1, head(x2)), A__SPLITAT(mark(tail(z0)), mark(head(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__head(mark(x2))), sel(z0, z1), x1, head(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(head(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__head(mark(x2))), afterNth(z0, z1), x1, head(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(head(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__head(mark(x2))), take(z0, z1), x1, head(x2)), A__SPLITAT(mark(take(z0, z1)), mark(head(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__head(mark(x2))), cons(z0, z1), x1, head(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(head(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__head(mark(x2))), s(z0), x1, head(x2)), A__SPLITAT(mark(s(z0)), mark(head(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__head(mark(x2))), pair(z0, z1), x1, head(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(head(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(0, a__head(mark(x2))), 0, x1, head(x2)), A__SPLITAT(mark(0), mark(head(x2))))
   A__SPLITAT(s(nil), cons(x1, head(x2))) -> c7(A__U(a__splitAt(nil, a__head(mark(x2))), nil, x1, head(x2)), A__SPLITAT(mark(nil), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(mark(x0), tail(mark(x2))), x0, x1, tail(x2)), A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__natsFrom(mark(z0)))), x0, x1, tail(natsFrom(z0))), A__SPLITAT(mark(x0), mark(tail(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__fst(mark(z0)))), x0, x1, tail(fst(z0))), A__SPLITAT(mark(x0), mark(tail(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__snd(mark(z0)))), x0, x1, tail(snd(z0))), A__SPLITAT(mark(x0), mark(tail(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__splitAt(mark(z0), mark(z1)))), x0, x1, tail(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(tail(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__u(mark(z0), z1, z2, z3))), x0, x1, tail(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(tail(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__head(mark(z0)))), x0, x1, tail(head(z0))), A__SPLITAT(mark(x0), mark(tail(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__tail(mark(z0)))), x0, x1, tail(tail(z0))), A__SPLITAT(mark(x0), mark(tail(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__sel(mark(z0), mark(z1)))), x0, x1, tail(sel(z0, z1))), A__SPLITAT(mark(x0), mark(tail(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__afterNth(mark(z0), mark(z1)))), x0, x1, tail(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(tail(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__take(mark(z0), mark(z1)))), x0, x1, tail(take(z0, z1))), A__SPLITAT(mark(x0), mark(tail(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(cons(mark(z0), z1))), x0, x1, tail(cons(z0, z1))), A__SPLITAT(mark(x0), mark(tail(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(s(mark(z0)))), x0, x1, tail(s(z0))), A__SPLITAT(mark(x0), mark(tail(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(pair(mark(z0), mark(z1)))), x0, x1, tail(pair(z0, z1))), A__SPLITAT(mark(x0), mark(tail(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(0)), x0, x1, tail(0)), A__SPLITAT(mark(x0), mark(tail(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(nil))) -> c7(A__U(a__splitAt(mark(x0), a__tail(nil)), x0, x1, tail(nil)), A__SPLITAT(mark(x0), mark(tail(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__tail(mark(x2))), natsFrom(z0), x1, tail(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(tail(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__tail(mark(x2))), fst(z0), x1, tail(x2)), A__SPLITAT(mark(fst(z0)), mark(tail(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__tail(mark(x2))), snd(z0), x1, tail(x2)), A__SPLITAT(mark(snd(z0)), mark(tail(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__tail(mark(x2))), splitAt(z0, z1), x1, tail(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(tail(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__tail(mark(x2))), u(z0, z1, z2, z3), x1, tail(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(tail(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__tail(mark(x2))), head(z0), x1, tail(x2)), A__SPLITAT(mark(head(z0)), mark(tail(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__tail(mark(x2))), tail(z0), x1, tail(x2)), A__SPLITAT(mark(tail(z0)), mark(tail(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__tail(mark(x2))), sel(z0, z1), x1, tail(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(tail(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__tail(mark(x2))), afterNth(z0, z1), x1, tail(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(tail(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__tail(mark(x2))), take(z0, z1), x1, tail(x2)), A__SPLITAT(mark(take(z0, z1)), mark(tail(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__tail(mark(x2))), cons(z0, z1), x1, tail(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(tail(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__tail(mark(x2))), s(z0), x1, tail(x2)), A__SPLITAT(mark(s(z0)), mark(tail(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__tail(mark(x2))), pair(z0, z1), x1, tail(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(tail(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(0, a__tail(mark(x2))), 0, x1, tail(x2)), A__SPLITAT(mark(0), mark(tail(x2))))
   A__SPLITAT(s(nil), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(nil, a__tail(mark(x2))), nil, x1, tail(x2)), A__SPLITAT(mark(nil), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(mark(x2)), mark(mark(x3))))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), sel(mark(x2), mark(x3))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__natsFrom(mark(z0)))), x0, x1, sel(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(sel(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__fst(mark(z0)))), x0, x1, sel(x2, fst(z0))), A__SPLITAT(mark(x0), mark(sel(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__snd(mark(z0)))), x0, x1, sel(x2, snd(z0))), A__SPLITAT(mark(x0), mark(sel(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, sel(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, sel(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(sel(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__head(mark(z0)))), x0, x1, sel(x2, head(z0))), A__SPLITAT(mark(x0), mark(sel(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__tail(mark(z0)))), x0, x1, sel(x2, tail(z0))), A__SPLITAT(mark(x0), mark(sel(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, sel(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, sel(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, sel(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), cons(mark(z0), z1))), x0, x1, sel(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), s(mark(z0)))), x0, x1, sel(x2, s(z0))), A__SPLITAT(mark(x0), mark(sel(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, sel(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), 0)), x0, x1, sel(x2, 0)), A__SPLITAT(mark(x0), mark(sel(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), nil)), x0, x1, sel(x2, nil)), A__SPLITAT(mark(x0), mark(sel(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__natsFrom(mark(z0)), mark(x3))), x0, x1, sel(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(sel(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__fst(mark(z0)), mark(x3))), x0, x1, sel(fst(z0), x3)), A__SPLITAT(mark(x0), mark(sel(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__snd(mark(z0)), mark(x3))), x0, x1, sel(snd(z0), x3)), A__SPLITAT(mark(x0), mark(sel(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, sel(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(sel(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__head(mark(z0)), mark(x3))), x0, x1, sel(head(z0), x3)), A__SPLITAT(mark(x0), mark(sel(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__tail(mark(z0)), mark(x3))), x0, x1, sel(tail(z0), x3)), A__SPLITAT(mark(x0), mark(sel(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(cons(mark(z0), z1), mark(x3))), x0, x1, sel(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(s(mark(z0)), mark(x3))), x0, x1, sel(s(z0), x3)), A__SPLITAT(mark(x0), mark(sel(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(0, mark(x3))), x0, x1, sel(0, x3)), A__SPLITAT(mark(x0), mark(sel(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(nil, mark(x3))), x0, x1, sel(nil, x3)), A__SPLITAT(mark(x0), mark(sel(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__sel(mark(x2), mark(x3))), natsFrom(z0), x1, sel(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(sel(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__sel(mark(x2), mark(x3))), fst(z0), x1, sel(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(sel(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__sel(mark(x2), mark(x3))), snd(z0), x1, sel(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(sel(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), splitAt(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(sel(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__sel(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, sel(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(sel(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__sel(mark(x2), mark(x3))), head(z0), x1, sel(x2, x3)), A__SPLITAT(mark(head(z0)), mark(sel(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__sel(mark(x2), mark(x3))), tail(z0), x1, sel(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(sel(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), sel(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(sel(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), afterNth(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(sel(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), take(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(sel(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__sel(mark(x2), mark(x3))), cons(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(sel(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__sel(mark(x2), mark(x3))), s(z0), x1, sel(x2, x3)), A__SPLITAT(mark(s(z0)), mark(sel(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), pair(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(sel(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(0, a__sel(mark(x2), mark(x3))), 0, x1, sel(x2, x3)), A__SPLITAT(mark(0), mark(sel(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(nil, a__sel(mark(x2), mark(x3))), nil, x1, sel(x2, x3)), A__SPLITAT(mark(nil), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(mark(x2)), mark(mark(x3))))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), afterNth(mark(x2), mark(x3))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__natsFrom(mark(z0)))), x0, x1, afterNth(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__fst(mark(z0)))), x0, x1, afterNth(x2, fst(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__snd(mark(z0)))), x0, x1, afterNth(x2, snd(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, afterNth(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, afterNth(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(afterNth(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__head(mark(z0)))), x0, x1, afterNth(x2, head(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__tail(mark(z0)))), x0, x1, afterNth(x2, tail(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, afterNth(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, afterNth(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, afterNth(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), cons(mark(z0), z1))), x0, x1, afterNth(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), s(mark(z0)))), x0, x1, afterNth(x2, s(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, afterNth(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), 0)), x0, x1, afterNth(x2, 0)), A__SPLITAT(mark(x0), mark(afterNth(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), nil)), x0, x1, afterNth(x2, nil)), A__SPLITAT(mark(x0), mark(afterNth(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__natsFrom(mark(z0)), mark(x3))), x0, x1, afterNth(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__fst(mark(z0)), mark(x3))), x0, x1, afterNth(fst(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__snd(mark(z0)), mark(x3))), x0, x1, afterNth(snd(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, afterNth(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(afterNth(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__head(mark(z0)), mark(x3))), x0, x1, afterNth(head(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__tail(mark(z0)), mark(x3))), x0, x1, afterNth(tail(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(cons(mark(z0), z1), mark(x3))), x0, x1, afterNth(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(s(mark(z0)), mark(x3))), x0, x1, afterNth(s(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(0, mark(x3))), x0, x1, afterNth(0, x3)), A__SPLITAT(mark(x0), mark(afterNth(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(nil, mark(x3))), x0, x1, afterNth(nil, x3)), A__SPLITAT(mark(x0), mark(afterNth(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__afterNth(mark(x2), mark(x3))), natsFrom(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(afterNth(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__afterNth(mark(x2), mark(x3))), fst(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(afterNth(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__afterNth(mark(x2), mark(x3))), snd(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(afterNth(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), splitAt(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(afterNth(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__afterNth(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, afterNth(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(afterNth(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__afterNth(mark(x2), mark(x3))), head(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(head(z0)), mark(afterNth(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__afterNth(mark(x2), mark(x3))), tail(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(afterNth(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), sel(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(afterNth(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), afterNth(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(afterNth(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), take(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(afterNth(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__afterNth(mark(x2), mark(x3))), cons(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(afterNth(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__afterNth(mark(x2), mark(x3))), s(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(s(z0)), mark(afterNth(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), pair(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(afterNth(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(afterNth(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(0, a__afterNth(mark(x2), mark(x3))), 0, x1, afterNth(x2, x3)), A__SPLITAT(mark(0), mark(afterNth(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(nil, a__afterNth(mark(x2), mark(x3))), nil, x1, afterNth(x2, x3)), A__SPLITAT(mark(nil), mark(afterNth(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__U(splitAt(mark(x0), a__take(mark(x2), mark(x3))), x0, x1, take(x2, x3)), A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(mark(x2)), mark(mark(x3))))), x0, x1, take(x2, x3)), A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), take(mark(x2), mark(x3))), x0, x1, take(x2, x3)), A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__natsFrom(mark(z0)))), x0, x1, take(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(take(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__fst(mark(z0)))), x0, x1, take(x2, fst(z0))), A__SPLITAT(mark(x0), mark(take(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__snd(mark(z0)))), x0, x1, take(x2, snd(z0))), A__SPLITAT(mark(x0), mark(take(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, take(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, take(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(take(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__head(mark(z0)))), x0, x1, take(x2, head(z0))), A__SPLITAT(mark(x0), mark(take(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__tail(mark(z0)))), x0, x1, take(x2, tail(z0))), A__SPLITAT(mark(x0), mark(take(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, take(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, take(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, take(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), cons(mark(z0), z1))), x0, x1, take(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), s(mark(z0)))), x0, x1, take(x2, s(z0))), A__SPLITAT(mark(x0), mark(take(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, take(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), 0)), x0, x1, take(x2, 0)), A__SPLITAT(mark(x0), mark(take(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), nil)), x0, x1, take(x2, nil)), A__SPLITAT(mark(x0), mark(take(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__natsFrom(mark(z0)), mark(x3))), x0, x1, take(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(take(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__fst(mark(z0)), mark(x3))), x0, x1, take(fst(z0), x3)), A__SPLITAT(mark(x0), mark(take(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__snd(mark(z0)), mark(x3))), x0, x1, take(snd(z0), x3)), A__SPLITAT(mark(x0), mark(take(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, take(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, take(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(take(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__head(mark(z0)), mark(x3))), x0, x1, take(head(z0), x3)), A__SPLITAT(mark(x0), mark(take(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__tail(mark(z0)), mark(x3))), x0, x1, take(tail(z0), x3)), A__SPLITAT(mark(x0), mark(take(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, take(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, take(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, take(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(cons(mark(z0), z1), mark(x3))), x0, x1, take(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(s(mark(z0)), mark(x3))), x0, x1, take(s(z0), x3)), A__SPLITAT(mark(x0), mark(take(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, take(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(0, mark(x3))), x0, x1, take(0, x3)), A__SPLITAT(mark(x0), mark(take(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(nil, mark(x3))), x0, x1, take(nil, x3)), A__SPLITAT(mark(x0), mark(take(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__take(mark(x2), mark(x3))), natsFrom(z0), x1, take(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(take(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__take(mark(x2), mark(x3))), fst(z0), x1, take(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(take(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__take(mark(x2), mark(x3))), snd(z0), x1, take(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(take(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), splitAt(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(take(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__take(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, take(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(take(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__take(mark(x2), mark(x3))), head(z0), x1, take(x2, x3)), A__SPLITAT(mark(head(z0)), mark(take(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__take(mark(x2), mark(x3))), tail(z0), x1, take(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(take(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), sel(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(take(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), afterNth(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(take(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), take(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(take(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__take(mark(x2), mark(x3))), cons(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(take(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__take(mark(x2), mark(x3))), s(z0), x1, take(x2, x3)), A__SPLITAT(mark(s(z0)), mark(take(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), pair(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(take(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(0, a__take(mark(x2), mark(x3))), 0, x1, take(x2, x3)), A__SPLITAT(mark(0), mark(take(x2, x3))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(nil, a__take(mark(x2), mark(x3))), nil, x1, take(x2, x3)), A__SPLITAT(mark(nil), mark(take(x2, x3))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(take(x2, x3))))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1, c33_2, c33_1, c7_1


----------------------------------------

(163) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 3 trailing tuple parts
----------------------------------------

(164)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(mark(x0), head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__natsFrom(mark(z0)))), x0, x1, head(natsFrom(z0))), A__SPLITAT(mark(x0), mark(head(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__fst(mark(z0)))), x0, x1, head(fst(z0))), A__SPLITAT(mark(x0), mark(head(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__snd(mark(z0)))), x0, x1, head(snd(z0))), A__SPLITAT(mark(x0), mark(head(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__splitAt(mark(z0), mark(z1)))), x0, x1, head(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(head(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__u(mark(z0), z1, z2, z3))), x0, x1, head(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(head(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__head(mark(z0)))), x0, x1, head(head(z0))), A__SPLITAT(mark(x0), mark(head(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__tail(mark(z0)))), x0, x1, head(tail(z0))), A__SPLITAT(mark(x0), mark(head(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__sel(mark(z0), mark(z1)))), x0, x1, head(sel(z0, z1))), A__SPLITAT(mark(x0), mark(head(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(z0), mark(z1)))), x0, x1, head(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(head(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__take(mark(z0), mark(z1)))), x0, x1, head(take(z0, z1))), A__SPLITAT(mark(x0), mark(head(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(cons(mark(z0), z1))), x0, x1, head(cons(z0, z1))), A__SPLITAT(mark(x0), mark(head(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(s(mark(z0)))), x0, x1, head(s(z0))), A__SPLITAT(mark(x0), mark(head(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(pair(mark(z0), mark(z1)))), x0, x1, head(pair(z0, z1))), A__SPLITAT(mark(x0), mark(head(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(0))) -> c7(A__U(a__splitAt(mark(x0), a__head(0)), x0, x1, head(0)), A__SPLITAT(mark(x0), mark(head(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(nil))) -> c7(A__U(a__splitAt(mark(x0), a__head(nil)), x0, x1, head(nil)), A__SPLITAT(mark(x0), mark(head(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__head(mark(x2))), natsFrom(z0), x1, head(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(head(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__head(mark(x2))), fst(z0), x1, head(x2)), A__SPLITAT(mark(fst(z0)), mark(head(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__head(mark(x2))), snd(z0), x1, head(x2)), A__SPLITAT(mark(snd(z0)), mark(head(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__head(mark(x2))), splitAt(z0, z1), x1, head(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(head(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__head(mark(x2))), u(z0, z1, z2, z3), x1, head(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(head(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__head(mark(x2))), head(z0), x1, head(x2)), A__SPLITAT(mark(head(z0)), mark(head(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__head(mark(x2))), tail(z0), x1, head(x2)), A__SPLITAT(mark(tail(z0)), mark(head(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__head(mark(x2))), sel(z0, z1), x1, head(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(head(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__head(mark(x2))), afterNth(z0, z1), x1, head(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(head(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__head(mark(x2))), take(z0, z1), x1, head(x2)), A__SPLITAT(mark(take(z0, z1)), mark(head(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__head(mark(x2))), cons(z0, z1), x1, head(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(head(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__head(mark(x2))), s(z0), x1, head(x2)), A__SPLITAT(mark(s(z0)), mark(head(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__head(mark(x2))), pair(z0, z1), x1, head(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(head(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(0, a__head(mark(x2))), 0, x1, head(x2)), A__SPLITAT(mark(0), mark(head(x2))))
   A__SPLITAT(s(nil), cons(x1, head(x2))) -> c7(A__U(a__splitAt(nil, a__head(mark(x2))), nil, x1, head(x2)), A__SPLITAT(mark(nil), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(mark(x0), tail(mark(x2))), x0, x1, tail(x2)), A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__natsFrom(mark(z0)))), x0, x1, tail(natsFrom(z0))), A__SPLITAT(mark(x0), mark(tail(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__fst(mark(z0)))), x0, x1, tail(fst(z0))), A__SPLITAT(mark(x0), mark(tail(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__snd(mark(z0)))), x0, x1, tail(snd(z0))), A__SPLITAT(mark(x0), mark(tail(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__splitAt(mark(z0), mark(z1)))), x0, x1, tail(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(tail(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__u(mark(z0), z1, z2, z3))), x0, x1, tail(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(tail(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__head(mark(z0)))), x0, x1, tail(head(z0))), A__SPLITAT(mark(x0), mark(tail(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__tail(mark(z0)))), x0, x1, tail(tail(z0))), A__SPLITAT(mark(x0), mark(tail(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__sel(mark(z0), mark(z1)))), x0, x1, tail(sel(z0, z1))), A__SPLITAT(mark(x0), mark(tail(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__afterNth(mark(z0), mark(z1)))), x0, x1, tail(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(tail(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__take(mark(z0), mark(z1)))), x0, x1, tail(take(z0, z1))), A__SPLITAT(mark(x0), mark(tail(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(cons(mark(z0), z1))), x0, x1, tail(cons(z0, z1))), A__SPLITAT(mark(x0), mark(tail(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(s(mark(z0)))), x0, x1, tail(s(z0))), A__SPLITAT(mark(x0), mark(tail(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(pair(mark(z0), mark(z1)))), x0, x1, tail(pair(z0, z1))), A__SPLITAT(mark(x0), mark(tail(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(0)), x0, x1, tail(0)), A__SPLITAT(mark(x0), mark(tail(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(nil))) -> c7(A__U(a__splitAt(mark(x0), a__tail(nil)), x0, x1, tail(nil)), A__SPLITAT(mark(x0), mark(tail(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__tail(mark(x2))), natsFrom(z0), x1, tail(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(tail(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__tail(mark(x2))), fst(z0), x1, tail(x2)), A__SPLITAT(mark(fst(z0)), mark(tail(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__tail(mark(x2))), snd(z0), x1, tail(x2)), A__SPLITAT(mark(snd(z0)), mark(tail(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__tail(mark(x2))), splitAt(z0, z1), x1, tail(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(tail(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__tail(mark(x2))), u(z0, z1, z2, z3), x1, tail(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(tail(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__tail(mark(x2))), head(z0), x1, tail(x2)), A__SPLITAT(mark(head(z0)), mark(tail(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__tail(mark(x2))), tail(z0), x1, tail(x2)), A__SPLITAT(mark(tail(z0)), mark(tail(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__tail(mark(x2))), sel(z0, z1), x1, tail(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(tail(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__tail(mark(x2))), afterNth(z0, z1), x1, tail(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(tail(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__tail(mark(x2))), take(z0, z1), x1, tail(x2)), A__SPLITAT(mark(take(z0, z1)), mark(tail(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__tail(mark(x2))), cons(z0, z1), x1, tail(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(tail(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__tail(mark(x2))), s(z0), x1, tail(x2)), A__SPLITAT(mark(s(z0)), mark(tail(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__tail(mark(x2))), pair(z0, z1), x1, tail(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(tail(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(0, a__tail(mark(x2))), 0, x1, tail(x2)), A__SPLITAT(mark(0), mark(tail(x2))))
   A__SPLITAT(s(nil), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(nil, a__tail(mark(x2))), nil, x1, tail(x2)), A__SPLITAT(mark(nil), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(mark(x2)), mark(mark(x3))))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), sel(mark(x2), mark(x3))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__natsFrom(mark(z0)))), x0, x1, sel(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(sel(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__fst(mark(z0)))), x0, x1, sel(x2, fst(z0))), A__SPLITAT(mark(x0), mark(sel(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__snd(mark(z0)))), x0, x1, sel(x2, snd(z0))), A__SPLITAT(mark(x0), mark(sel(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, sel(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, sel(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(sel(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__head(mark(z0)))), x0, x1, sel(x2, head(z0))), A__SPLITAT(mark(x0), mark(sel(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__tail(mark(z0)))), x0, x1, sel(x2, tail(z0))), A__SPLITAT(mark(x0), mark(sel(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, sel(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, sel(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, sel(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), cons(mark(z0), z1))), x0, x1, sel(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), s(mark(z0)))), x0, x1, sel(x2, s(z0))), A__SPLITAT(mark(x0), mark(sel(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, sel(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), 0)), x0, x1, sel(x2, 0)), A__SPLITAT(mark(x0), mark(sel(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), nil)), x0, x1, sel(x2, nil)), A__SPLITAT(mark(x0), mark(sel(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__natsFrom(mark(z0)), mark(x3))), x0, x1, sel(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(sel(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__fst(mark(z0)), mark(x3))), x0, x1, sel(fst(z0), x3)), A__SPLITAT(mark(x0), mark(sel(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__snd(mark(z0)), mark(x3))), x0, x1, sel(snd(z0), x3)), A__SPLITAT(mark(x0), mark(sel(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, sel(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(sel(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__head(mark(z0)), mark(x3))), x0, x1, sel(head(z0), x3)), A__SPLITAT(mark(x0), mark(sel(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__tail(mark(z0)), mark(x3))), x0, x1, sel(tail(z0), x3)), A__SPLITAT(mark(x0), mark(sel(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(cons(mark(z0), z1), mark(x3))), x0, x1, sel(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(s(mark(z0)), mark(x3))), x0, x1, sel(s(z0), x3)), A__SPLITAT(mark(x0), mark(sel(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(0, mark(x3))), x0, x1, sel(0, x3)), A__SPLITAT(mark(x0), mark(sel(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(nil, mark(x3))), x0, x1, sel(nil, x3)), A__SPLITAT(mark(x0), mark(sel(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__sel(mark(x2), mark(x3))), natsFrom(z0), x1, sel(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(sel(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__sel(mark(x2), mark(x3))), fst(z0), x1, sel(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(sel(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__sel(mark(x2), mark(x3))), snd(z0), x1, sel(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(sel(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), splitAt(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(sel(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__sel(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, sel(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(sel(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__sel(mark(x2), mark(x3))), head(z0), x1, sel(x2, x3)), A__SPLITAT(mark(head(z0)), mark(sel(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__sel(mark(x2), mark(x3))), tail(z0), x1, sel(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(sel(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), sel(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(sel(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), afterNth(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(sel(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), take(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(sel(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__sel(mark(x2), mark(x3))), cons(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(sel(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__sel(mark(x2), mark(x3))), s(z0), x1, sel(x2, x3)), A__SPLITAT(mark(s(z0)), mark(sel(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), pair(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(sel(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(0, a__sel(mark(x2), mark(x3))), 0, x1, sel(x2, x3)), A__SPLITAT(mark(0), mark(sel(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(nil, a__sel(mark(x2), mark(x3))), nil, x1, sel(x2, x3)), A__SPLITAT(mark(nil), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(mark(x2)), mark(mark(x3))))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), afterNth(mark(x2), mark(x3))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__natsFrom(mark(z0)))), x0, x1, afterNth(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__fst(mark(z0)))), x0, x1, afterNth(x2, fst(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__snd(mark(z0)))), x0, x1, afterNth(x2, snd(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, afterNth(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, afterNth(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(afterNth(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__head(mark(z0)))), x0, x1, afterNth(x2, head(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__tail(mark(z0)))), x0, x1, afterNth(x2, tail(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, afterNth(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, afterNth(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, afterNth(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), cons(mark(z0), z1))), x0, x1, afterNth(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), s(mark(z0)))), x0, x1, afterNth(x2, s(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, afterNth(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), 0)), x0, x1, afterNth(x2, 0)), A__SPLITAT(mark(x0), mark(afterNth(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), nil)), x0, x1, afterNth(x2, nil)), A__SPLITAT(mark(x0), mark(afterNth(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__natsFrom(mark(z0)), mark(x3))), x0, x1, afterNth(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__fst(mark(z0)), mark(x3))), x0, x1, afterNth(fst(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__snd(mark(z0)), mark(x3))), x0, x1, afterNth(snd(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, afterNth(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(afterNth(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__head(mark(z0)), mark(x3))), x0, x1, afterNth(head(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__tail(mark(z0)), mark(x3))), x0, x1, afterNth(tail(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(cons(mark(z0), z1), mark(x3))), x0, x1, afterNth(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(s(mark(z0)), mark(x3))), x0, x1, afterNth(s(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(0, mark(x3))), x0, x1, afterNth(0, x3)), A__SPLITAT(mark(x0), mark(afterNth(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(nil, mark(x3))), x0, x1, afterNth(nil, x3)), A__SPLITAT(mark(x0), mark(afterNth(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__afterNth(mark(x2), mark(x3))), natsFrom(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(afterNth(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__afterNth(mark(x2), mark(x3))), fst(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(afterNth(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__afterNth(mark(x2), mark(x3))), snd(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(afterNth(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), splitAt(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(afterNth(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__afterNth(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, afterNth(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(afterNth(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__afterNth(mark(x2), mark(x3))), head(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(head(z0)), mark(afterNth(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__afterNth(mark(x2), mark(x3))), tail(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(afterNth(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), sel(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(afterNth(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), afterNth(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(afterNth(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), take(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(afterNth(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__afterNth(mark(x2), mark(x3))), cons(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(afterNth(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__afterNth(mark(x2), mark(x3))), s(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(s(z0)), mark(afterNth(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), pair(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(afterNth(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(afterNth(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(0, a__afterNth(mark(x2), mark(x3))), 0, x1, afterNth(x2, x3)), A__SPLITAT(mark(0), mark(afterNth(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(nil, a__afterNth(mark(x2), mark(x3))), nil, x1, afterNth(x2, x3)), A__SPLITAT(mark(nil), mark(afterNth(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(mark(x2)), mark(mark(x3))))), x0, x1, take(x2, x3)), A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), take(mark(x2), mark(x3))), x0, x1, take(x2, x3)), A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__natsFrom(mark(z0)))), x0, x1, take(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(take(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__fst(mark(z0)))), x0, x1, take(x2, fst(z0))), A__SPLITAT(mark(x0), mark(take(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__snd(mark(z0)))), x0, x1, take(x2, snd(z0))), A__SPLITAT(mark(x0), mark(take(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, take(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, take(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(take(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__head(mark(z0)))), x0, x1, take(x2, head(z0))), A__SPLITAT(mark(x0), mark(take(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__tail(mark(z0)))), x0, x1, take(x2, tail(z0))), A__SPLITAT(mark(x0), mark(take(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, take(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, take(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, take(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), cons(mark(z0), z1))), x0, x1, take(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), s(mark(z0)))), x0, x1, take(x2, s(z0))), A__SPLITAT(mark(x0), mark(take(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, take(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), 0)), x0, x1, take(x2, 0)), A__SPLITAT(mark(x0), mark(take(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), nil)), x0, x1, take(x2, nil)), A__SPLITAT(mark(x0), mark(take(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__natsFrom(mark(z0)), mark(x3))), x0, x1, take(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(take(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__fst(mark(z0)), mark(x3))), x0, x1, take(fst(z0), x3)), A__SPLITAT(mark(x0), mark(take(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__snd(mark(z0)), mark(x3))), x0, x1, take(snd(z0), x3)), A__SPLITAT(mark(x0), mark(take(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, take(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, take(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(take(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__head(mark(z0)), mark(x3))), x0, x1, take(head(z0), x3)), A__SPLITAT(mark(x0), mark(take(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__tail(mark(z0)), mark(x3))), x0, x1, take(tail(z0), x3)), A__SPLITAT(mark(x0), mark(take(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, take(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, take(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, take(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(cons(mark(z0), z1), mark(x3))), x0, x1, take(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(s(mark(z0)), mark(x3))), x0, x1, take(s(z0), x3)), A__SPLITAT(mark(x0), mark(take(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, take(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(0, mark(x3))), x0, x1, take(0, x3)), A__SPLITAT(mark(x0), mark(take(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(nil, mark(x3))), x0, x1, take(nil, x3)), A__SPLITAT(mark(x0), mark(take(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__take(mark(x2), mark(x3))), natsFrom(z0), x1, take(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(take(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__take(mark(x2), mark(x3))), fst(z0), x1, take(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(take(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__take(mark(x2), mark(x3))), snd(z0), x1, take(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(take(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), splitAt(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(take(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__take(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, take(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(take(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__take(mark(x2), mark(x3))), head(z0), x1, take(x2, x3)), A__SPLITAT(mark(head(z0)), mark(take(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__take(mark(x2), mark(x3))), tail(z0), x1, take(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(take(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), sel(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(take(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), afterNth(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(take(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), take(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(take(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__take(mark(x2), mark(x3))), cons(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(take(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__take(mark(x2), mark(x3))), s(z0), x1, take(x2, x3)), A__SPLITAT(mark(s(z0)), mark(take(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), pair(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(take(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(take(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(0, a__take(mark(x2), mark(x3))), 0, x1, take(x2, x3)), A__SPLITAT(mark(0), mark(take(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(nil, a__take(mark(x2), mark(x3))), nil, x1, take(x2, x3)), A__SPLITAT(mark(nil), mark(take(x2, x3))))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(mark(x0), head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__natsFrom(mark(z0)))), x0, x1, head(natsFrom(z0))), A__SPLITAT(mark(x0), mark(head(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__fst(mark(z0)))), x0, x1, head(fst(z0))), A__SPLITAT(mark(x0), mark(head(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__snd(mark(z0)))), x0, x1, head(snd(z0))), A__SPLITAT(mark(x0), mark(head(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__splitAt(mark(z0), mark(z1)))), x0, x1, head(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(head(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__u(mark(z0), z1, z2, z3))), x0, x1, head(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(head(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__head(mark(z0)))), x0, x1, head(head(z0))), A__SPLITAT(mark(x0), mark(head(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__tail(mark(z0)))), x0, x1, head(tail(z0))), A__SPLITAT(mark(x0), mark(head(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__sel(mark(z0), mark(z1)))), x0, x1, head(sel(z0, z1))), A__SPLITAT(mark(x0), mark(head(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(z0), mark(z1)))), x0, x1, head(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(head(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__take(mark(z0), mark(z1)))), x0, x1, head(take(z0, z1))), A__SPLITAT(mark(x0), mark(head(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(cons(mark(z0), z1))), x0, x1, head(cons(z0, z1))), A__SPLITAT(mark(x0), mark(head(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(s(mark(z0)))), x0, x1, head(s(z0))), A__SPLITAT(mark(x0), mark(head(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(pair(mark(z0), mark(z1)))), x0, x1, head(pair(z0, z1))), A__SPLITAT(mark(x0), mark(head(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(0))) -> c7(A__U(a__splitAt(mark(x0), a__head(0)), x0, x1, head(0)), A__SPLITAT(mark(x0), mark(head(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(nil))) -> c7(A__U(a__splitAt(mark(x0), a__head(nil)), x0, x1, head(nil)), A__SPLITAT(mark(x0), mark(head(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__head(mark(x2))), natsFrom(z0), x1, head(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(head(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__head(mark(x2))), fst(z0), x1, head(x2)), A__SPLITAT(mark(fst(z0)), mark(head(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__head(mark(x2))), snd(z0), x1, head(x2)), A__SPLITAT(mark(snd(z0)), mark(head(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__head(mark(x2))), splitAt(z0, z1), x1, head(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(head(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__head(mark(x2))), u(z0, z1, z2, z3), x1, head(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(head(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__head(mark(x2))), head(z0), x1, head(x2)), A__SPLITAT(mark(head(z0)), mark(head(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__head(mark(x2))), tail(z0), x1, head(x2)), A__SPLITAT(mark(tail(z0)), mark(head(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__head(mark(x2))), sel(z0, z1), x1, head(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(head(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__head(mark(x2))), afterNth(z0, z1), x1, head(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(head(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__head(mark(x2))), take(z0, z1), x1, head(x2)), A__SPLITAT(mark(take(z0, z1)), mark(head(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__head(mark(x2))), cons(z0, z1), x1, head(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(head(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__head(mark(x2))), s(z0), x1, head(x2)), A__SPLITAT(mark(s(z0)), mark(head(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__head(mark(x2))), pair(z0, z1), x1, head(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(head(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(0, a__head(mark(x2))), 0, x1, head(x2)), A__SPLITAT(mark(0), mark(head(x2))))
   A__SPLITAT(s(nil), cons(x1, head(x2))) -> c7(A__U(a__splitAt(nil, a__head(mark(x2))), nil, x1, head(x2)), A__SPLITAT(mark(nil), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(mark(x0), tail(mark(x2))), x0, x1, tail(x2)), A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__natsFrom(mark(z0)))), x0, x1, tail(natsFrom(z0))), A__SPLITAT(mark(x0), mark(tail(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__fst(mark(z0)))), x0, x1, tail(fst(z0))), A__SPLITAT(mark(x0), mark(tail(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__snd(mark(z0)))), x0, x1, tail(snd(z0))), A__SPLITAT(mark(x0), mark(tail(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__splitAt(mark(z0), mark(z1)))), x0, x1, tail(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(tail(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__u(mark(z0), z1, z2, z3))), x0, x1, tail(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(tail(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__head(mark(z0)))), x0, x1, tail(head(z0))), A__SPLITAT(mark(x0), mark(tail(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__tail(mark(z0)))), x0, x1, tail(tail(z0))), A__SPLITAT(mark(x0), mark(tail(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__sel(mark(z0), mark(z1)))), x0, x1, tail(sel(z0, z1))), A__SPLITAT(mark(x0), mark(tail(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__afterNth(mark(z0), mark(z1)))), x0, x1, tail(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(tail(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__take(mark(z0), mark(z1)))), x0, x1, tail(take(z0, z1))), A__SPLITAT(mark(x0), mark(tail(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(cons(mark(z0), z1))), x0, x1, tail(cons(z0, z1))), A__SPLITAT(mark(x0), mark(tail(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(s(mark(z0)))), x0, x1, tail(s(z0))), A__SPLITAT(mark(x0), mark(tail(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(pair(mark(z0), mark(z1)))), x0, x1, tail(pair(z0, z1))), A__SPLITAT(mark(x0), mark(tail(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(0)), x0, x1, tail(0)), A__SPLITAT(mark(x0), mark(tail(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(nil))) -> c7(A__U(a__splitAt(mark(x0), a__tail(nil)), x0, x1, tail(nil)), A__SPLITAT(mark(x0), mark(tail(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__tail(mark(x2))), natsFrom(z0), x1, tail(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(tail(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__tail(mark(x2))), fst(z0), x1, tail(x2)), A__SPLITAT(mark(fst(z0)), mark(tail(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__tail(mark(x2))), snd(z0), x1, tail(x2)), A__SPLITAT(mark(snd(z0)), mark(tail(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__tail(mark(x2))), splitAt(z0, z1), x1, tail(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(tail(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__tail(mark(x2))), u(z0, z1, z2, z3), x1, tail(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(tail(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__tail(mark(x2))), head(z0), x1, tail(x2)), A__SPLITAT(mark(head(z0)), mark(tail(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__tail(mark(x2))), tail(z0), x1, tail(x2)), A__SPLITAT(mark(tail(z0)), mark(tail(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__tail(mark(x2))), sel(z0, z1), x1, tail(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(tail(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__tail(mark(x2))), afterNth(z0, z1), x1, tail(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(tail(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__tail(mark(x2))), take(z0, z1), x1, tail(x2)), A__SPLITAT(mark(take(z0, z1)), mark(tail(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__tail(mark(x2))), cons(z0, z1), x1, tail(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(tail(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__tail(mark(x2))), s(z0), x1, tail(x2)), A__SPLITAT(mark(s(z0)), mark(tail(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__tail(mark(x2))), pair(z0, z1), x1, tail(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(tail(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(0, a__tail(mark(x2))), 0, x1, tail(x2)), A__SPLITAT(mark(0), mark(tail(x2))))
   A__SPLITAT(s(nil), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(nil, a__tail(mark(x2))), nil, x1, tail(x2)), A__SPLITAT(mark(nil), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(mark(x2)), mark(mark(x3))))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), sel(mark(x2), mark(x3))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__natsFrom(mark(z0)))), x0, x1, sel(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(sel(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__fst(mark(z0)))), x0, x1, sel(x2, fst(z0))), A__SPLITAT(mark(x0), mark(sel(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__snd(mark(z0)))), x0, x1, sel(x2, snd(z0))), A__SPLITAT(mark(x0), mark(sel(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, sel(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, sel(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(sel(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__head(mark(z0)))), x0, x1, sel(x2, head(z0))), A__SPLITAT(mark(x0), mark(sel(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__tail(mark(z0)))), x0, x1, sel(x2, tail(z0))), A__SPLITAT(mark(x0), mark(sel(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, sel(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, sel(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, sel(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), cons(mark(z0), z1))), x0, x1, sel(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), s(mark(z0)))), x0, x1, sel(x2, s(z0))), A__SPLITAT(mark(x0), mark(sel(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, sel(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), 0)), x0, x1, sel(x2, 0)), A__SPLITAT(mark(x0), mark(sel(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), nil)), x0, x1, sel(x2, nil)), A__SPLITAT(mark(x0), mark(sel(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__natsFrom(mark(z0)), mark(x3))), x0, x1, sel(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(sel(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__fst(mark(z0)), mark(x3))), x0, x1, sel(fst(z0), x3)), A__SPLITAT(mark(x0), mark(sel(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__snd(mark(z0)), mark(x3))), x0, x1, sel(snd(z0), x3)), A__SPLITAT(mark(x0), mark(sel(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, sel(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(sel(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__head(mark(z0)), mark(x3))), x0, x1, sel(head(z0), x3)), A__SPLITAT(mark(x0), mark(sel(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__tail(mark(z0)), mark(x3))), x0, x1, sel(tail(z0), x3)), A__SPLITAT(mark(x0), mark(sel(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(cons(mark(z0), z1), mark(x3))), x0, x1, sel(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(s(mark(z0)), mark(x3))), x0, x1, sel(s(z0), x3)), A__SPLITAT(mark(x0), mark(sel(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(0, mark(x3))), x0, x1, sel(0, x3)), A__SPLITAT(mark(x0), mark(sel(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(nil, mark(x3))), x0, x1, sel(nil, x3)), A__SPLITAT(mark(x0), mark(sel(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__sel(mark(x2), mark(x3))), natsFrom(z0), x1, sel(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(sel(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__sel(mark(x2), mark(x3))), fst(z0), x1, sel(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(sel(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__sel(mark(x2), mark(x3))), snd(z0), x1, sel(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(sel(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), splitAt(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(sel(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__sel(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, sel(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(sel(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__sel(mark(x2), mark(x3))), head(z0), x1, sel(x2, x3)), A__SPLITAT(mark(head(z0)), mark(sel(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__sel(mark(x2), mark(x3))), tail(z0), x1, sel(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(sel(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), sel(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(sel(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), afterNth(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(sel(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), take(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(sel(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__sel(mark(x2), mark(x3))), cons(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(sel(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__sel(mark(x2), mark(x3))), s(z0), x1, sel(x2, x3)), A__SPLITAT(mark(s(z0)), mark(sel(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), pair(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(sel(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(0, a__sel(mark(x2), mark(x3))), 0, x1, sel(x2, x3)), A__SPLITAT(mark(0), mark(sel(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(nil, a__sel(mark(x2), mark(x3))), nil, x1, sel(x2, x3)), A__SPLITAT(mark(nil), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(mark(x2)), mark(mark(x3))))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), afterNth(mark(x2), mark(x3))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__natsFrom(mark(z0)))), x0, x1, afterNth(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__fst(mark(z0)))), x0, x1, afterNth(x2, fst(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__snd(mark(z0)))), x0, x1, afterNth(x2, snd(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, afterNth(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, afterNth(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(afterNth(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__head(mark(z0)))), x0, x1, afterNth(x2, head(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__tail(mark(z0)))), x0, x1, afterNth(x2, tail(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, afterNth(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, afterNth(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, afterNth(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), cons(mark(z0), z1))), x0, x1, afterNth(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), s(mark(z0)))), x0, x1, afterNth(x2, s(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, afterNth(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), 0)), x0, x1, afterNth(x2, 0)), A__SPLITAT(mark(x0), mark(afterNth(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), nil)), x0, x1, afterNth(x2, nil)), A__SPLITAT(mark(x0), mark(afterNth(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__natsFrom(mark(z0)), mark(x3))), x0, x1, afterNth(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__fst(mark(z0)), mark(x3))), x0, x1, afterNth(fst(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__snd(mark(z0)), mark(x3))), x0, x1, afterNth(snd(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, afterNth(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(afterNth(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__head(mark(z0)), mark(x3))), x0, x1, afterNth(head(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__tail(mark(z0)), mark(x3))), x0, x1, afterNth(tail(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(cons(mark(z0), z1), mark(x3))), x0, x1, afterNth(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(s(mark(z0)), mark(x3))), x0, x1, afterNth(s(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(0, mark(x3))), x0, x1, afterNth(0, x3)), A__SPLITAT(mark(x0), mark(afterNth(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(nil, mark(x3))), x0, x1, afterNth(nil, x3)), A__SPLITAT(mark(x0), mark(afterNth(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__afterNth(mark(x2), mark(x3))), natsFrom(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(afterNth(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__afterNth(mark(x2), mark(x3))), fst(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(afterNth(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__afterNth(mark(x2), mark(x3))), snd(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(afterNth(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), splitAt(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(afterNth(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__afterNth(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, afterNth(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(afterNth(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__afterNth(mark(x2), mark(x3))), head(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(head(z0)), mark(afterNth(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__afterNth(mark(x2), mark(x3))), tail(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(afterNth(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), sel(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(afterNth(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), afterNth(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(afterNth(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), take(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(afterNth(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__afterNth(mark(x2), mark(x3))), cons(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(afterNth(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__afterNth(mark(x2), mark(x3))), s(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(s(z0)), mark(afterNth(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), pair(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(afterNth(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(afterNth(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(0, a__afterNth(mark(x2), mark(x3))), 0, x1, afterNth(x2, x3)), A__SPLITAT(mark(0), mark(afterNth(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(nil, a__afterNth(mark(x2), mark(x3))), nil, x1, afterNth(x2, x3)), A__SPLITAT(mark(nil), mark(afterNth(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(mark(x2)), mark(mark(x3))))), x0, x1, take(x2, x3)), A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), take(mark(x2), mark(x3))), x0, x1, take(x2, x3)), A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__natsFrom(mark(z0)))), x0, x1, take(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(take(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__fst(mark(z0)))), x0, x1, take(x2, fst(z0))), A__SPLITAT(mark(x0), mark(take(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__snd(mark(z0)))), x0, x1, take(x2, snd(z0))), A__SPLITAT(mark(x0), mark(take(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, take(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, take(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(take(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__head(mark(z0)))), x0, x1, take(x2, head(z0))), A__SPLITAT(mark(x0), mark(take(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__tail(mark(z0)))), x0, x1, take(x2, tail(z0))), A__SPLITAT(mark(x0), mark(take(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, take(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, take(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, take(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), cons(mark(z0), z1))), x0, x1, take(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), s(mark(z0)))), x0, x1, take(x2, s(z0))), A__SPLITAT(mark(x0), mark(take(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, take(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), 0)), x0, x1, take(x2, 0)), A__SPLITAT(mark(x0), mark(take(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), nil)), x0, x1, take(x2, nil)), A__SPLITAT(mark(x0), mark(take(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__natsFrom(mark(z0)), mark(x3))), x0, x1, take(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(take(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__fst(mark(z0)), mark(x3))), x0, x1, take(fst(z0), x3)), A__SPLITAT(mark(x0), mark(take(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__snd(mark(z0)), mark(x3))), x0, x1, take(snd(z0), x3)), A__SPLITAT(mark(x0), mark(take(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, take(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, take(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(take(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__head(mark(z0)), mark(x3))), x0, x1, take(head(z0), x3)), A__SPLITAT(mark(x0), mark(take(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__tail(mark(z0)), mark(x3))), x0, x1, take(tail(z0), x3)), A__SPLITAT(mark(x0), mark(take(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, take(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, take(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, take(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(cons(mark(z0), z1), mark(x3))), x0, x1, take(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(s(mark(z0)), mark(x3))), x0, x1, take(s(z0), x3)), A__SPLITAT(mark(x0), mark(take(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, take(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(0, mark(x3))), x0, x1, take(0, x3)), A__SPLITAT(mark(x0), mark(take(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(nil, mark(x3))), x0, x1, take(nil, x3)), A__SPLITAT(mark(x0), mark(take(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__take(mark(x2), mark(x3))), natsFrom(z0), x1, take(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(take(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__take(mark(x2), mark(x3))), fst(z0), x1, take(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(take(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__take(mark(x2), mark(x3))), snd(z0), x1, take(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(take(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), splitAt(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(take(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__take(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, take(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(take(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__take(mark(x2), mark(x3))), head(z0), x1, take(x2, x3)), A__SPLITAT(mark(head(z0)), mark(take(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__take(mark(x2), mark(x3))), tail(z0), x1, take(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(take(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), sel(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(take(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), afterNth(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(take(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), take(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(take(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__take(mark(x2), mark(x3))), cons(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(take(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__take(mark(x2), mark(x3))), s(z0), x1, take(x2, x3)), A__SPLITAT(mark(s(z0)), mark(take(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), pair(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(take(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(take(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(0, a__take(mark(x2), mark(x3))), 0, x1, take(x2, x3)), A__SPLITAT(mark(0), mark(take(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(nil, a__take(mark(x2), mark(x3))), nil, x1, take(x2, x3)), A__SPLITAT(mark(nil), mark(take(x2, x3))))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1, c33_2, c33_1, c7_1


----------------------------------------

(165) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0)) by 
   A__SPLITAT(s(x0), cons(x1, cons(x2, x3))) -> c7(A__U(splitAt(mark(x0), cons(mark(x2), x3)), x0, x1, cons(x2, x3)), A__SPLITAT(mark(x0), mark(cons(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__natsFrom(mark(z0)), x3)), x0, x1, cons(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(cons(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__fst(mark(z0)), x3)), x0, x1, cons(fst(z0), x3)), A__SPLITAT(mark(x0), mark(cons(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__snd(mark(z0)), x3)), x0, x1, cons(snd(z0), x3)), A__SPLITAT(mark(x0), mark(cons(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__splitAt(mark(z0), mark(z1)), x3)), x0, x1, cons(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__u(mark(z0), z1, z2, z3), x3)), x0, x1, cons(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(cons(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__head(mark(z0)), x3)), x0, x1, cons(head(z0), x3)), A__SPLITAT(mark(x0), mark(cons(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__tail(mark(z0)), x3)), x0, x1, cons(tail(z0), x3)), A__SPLITAT(mark(x0), mark(cons(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__sel(mark(z0), mark(z1)), x3)), x0, x1, cons(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__afterNth(mark(z0), mark(z1)), x3)), x0, x1, cons(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__take(mark(z0), mark(z1)), x3)), x0, x1, cons(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(cons(mark(z0), z1), x3)), x0, x1, cons(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(s(mark(z0)), x3)), x0, x1, cons(s(z0), x3)), A__SPLITAT(mark(x0), mark(cons(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(pair(mark(z0), mark(z1)), x3)), x0, x1, cons(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(0, x3))) -> c7(A__U(a__splitAt(mark(x0), cons(0, x3)), x0, x1, cons(0, x3)), A__SPLITAT(mark(x0), mark(cons(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), cons(nil, x3)), x0, x1, cons(nil, x3)), A__SPLITAT(mark(x0), mark(cons(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), cons(mark(x2), x3)), natsFrom(z0), x1, cons(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(cons(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), cons(mark(x2), x3)), fst(z0), x1, cons(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(cons(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), cons(mark(x2), x3)), snd(z0), x1, cons(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(cons(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), cons(mark(x2), x3)), splitAt(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(cons(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), cons(mark(x2), x3)), u(z0, z1, z2, z3), x1, cons(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(cons(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), cons(mark(x2), x3)), head(z0), x1, cons(x2, x3)), A__SPLITAT(mark(head(z0)), mark(cons(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), cons(mark(x2), x3)), tail(z0), x1, cons(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(cons(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), cons(mark(x2), x3)), sel(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(cons(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), cons(mark(x2), x3)), afterNth(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(cons(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), cons(mark(x2), x3)), take(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(cons(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), cons(mark(x2), x3)), cons(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(cons(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), cons(mark(x2), x3)), s(z0), x1, cons(x2, x3)), A__SPLITAT(mark(s(z0)), mark(cons(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), cons(mark(x2), x3)), pair(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(cons(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(0, cons(mark(x2), x3)), 0, x1, cons(x2, x3)), A__SPLITAT(mark(0), mark(cons(x2, x3))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(nil, cons(mark(x2), x3)), nil, x1, cons(x2, x3)), A__SPLITAT(mark(nil), mark(cons(x2, x3))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, cons(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(cons(x2, x3))))

----------------------------------------

(166)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(mark(x0), head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__natsFrom(mark(z0)))), x0, x1, head(natsFrom(z0))), A__SPLITAT(mark(x0), mark(head(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__fst(mark(z0)))), x0, x1, head(fst(z0))), A__SPLITAT(mark(x0), mark(head(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__snd(mark(z0)))), x0, x1, head(snd(z0))), A__SPLITAT(mark(x0), mark(head(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__splitAt(mark(z0), mark(z1)))), x0, x1, head(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(head(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__u(mark(z0), z1, z2, z3))), x0, x1, head(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(head(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__head(mark(z0)))), x0, x1, head(head(z0))), A__SPLITAT(mark(x0), mark(head(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__tail(mark(z0)))), x0, x1, head(tail(z0))), A__SPLITAT(mark(x0), mark(head(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__sel(mark(z0), mark(z1)))), x0, x1, head(sel(z0, z1))), A__SPLITAT(mark(x0), mark(head(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(z0), mark(z1)))), x0, x1, head(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(head(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__take(mark(z0), mark(z1)))), x0, x1, head(take(z0, z1))), A__SPLITAT(mark(x0), mark(head(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(cons(mark(z0), z1))), x0, x1, head(cons(z0, z1))), A__SPLITAT(mark(x0), mark(head(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(s(mark(z0)))), x0, x1, head(s(z0))), A__SPLITAT(mark(x0), mark(head(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(pair(mark(z0), mark(z1)))), x0, x1, head(pair(z0, z1))), A__SPLITAT(mark(x0), mark(head(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(0))) -> c7(A__U(a__splitAt(mark(x0), a__head(0)), x0, x1, head(0)), A__SPLITAT(mark(x0), mark(head(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(nil))) -> c7(A__U(a__splitAt(mark(x0), a__head(nil)), x0, x1, head(nil)), A__SPLITAT(mark(x0), mark(head(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__head(mark(x2))), natsFrom(z0), x1, head(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(head(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__head(mark(x2))), fst(z0), x1, head(x2)), A__SPLITAT(mark(fst(z0)), mark(head(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__head(mark(x2))), snd(z0), x1, head(x2)), A__SPLITAT(mark(snd(z0)), mark(head(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__head(mark(x2))), splitAt(z0, z1), x1, head(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(head(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__head(mark(x2))), u(z0, z1, z2, z3), x1, head(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(head(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__head(mark(x2))), head(z0), x1, head(x2)), A__SPLITAT(mark(head(z0)), mark(head(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__head(mark(x2))), tail(z0), x1, head(x2)), A__SPLITAT(mark(tail(z0)), mark(head(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__head(mark(x2))), sel(z0, z1), x1, head(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(head(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__head(mark(x2))), afterNth(z0, z1), x1, head(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(head(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__head(mark(x2))), take(z0, z1), x1, head(x2)), A__SPLITAT(mark(take(z0, z1)), mark(head(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__head(mark(x2))), cons(z0, z1), x1, head(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(head(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__head(mark(x2))), s(z0), x1, head(x2)), A__SPLITAT(mark(s(z0)), mark(head(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__head(mark(x2))), pair(z0, z1), x1, head(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(head(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(0, a__head(mark(x2))), 0, x1, head(x2)), A__SPLITAT(mark(0), mark(head(x2))))
   A__SPLITAT(s(nil), cons(x1, head(x2))) -> c7(A__U(a__splitAt(nil, a__head(mark(x2))), nil, x1, head(x2)), A__SPLITAT(mark(nil), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(mark(x0), tail(mark(x2))), x0, x1, tail(x2)), A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__natsFrom(mark(z0)))), x0, x1, tail(natsFrom(z0))), A__SPLITAT(mark(x0), mark(tail(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__fst(mark(z0)))), x0, x1, tail(fst(z0))), A__SPLITAT(mark(x0), mark(tail(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__snd(mark(z0)))), x0, x1, tail(snd(z0))), A__SPLITAT(mark(x0), mark(tail(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__splitAt(mark(z0), mark(z1)))), x0, x1, tail(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(tail(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__u(mark(z0), z1, z2, z3))), x0, x1, tail(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(tail(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__head(mark(z0)))), x0, x1, tail(head(z0))), A__SPLITAT(mark(x0), mark(tail(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__tail(mark(z0)))), x0, x1, tail(tail(z0))), A__SPLITAT(mark(x0), mark(tail(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__sel(mark(z0), mark(z1)))), x0, x1, tail(sel(z0, z1))), A__SPLITAT(mark(x0), mark(tail(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__afterNth(mark(z0), mark(z1)))), x0, x1, tail(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(tail(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__take(mark(z0), mark(z1)))), x0, x1, tail(take(z0, z1))), A__SPLITAT(mark(x0), mark(tail(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(cons(mark(z0), z1))), x0, x1, tail(cons(z0, z1))), A__SPLITAT(mark(x0), mark(tail(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(s(mark(z0)))), x0, x1, tail(s(z0))), A__SPLITAT(mark(x0), mark(tail(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(pair(mark(z0), mark(z1)))), x0, x1, tail(pair(z0, z1))), A__SPLITAT(mark(x0), mark(tail(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(0)), x0, x1, tail(0)), A__SPLITAT(mark(x0), mark(tail(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(nil))) -> c7(A__U(a__splitAt(mark(x0), a__tail(nil)), x0, x1, tail(nil)), A__SPLITAT(mark(x0), mark(tail(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__tail(mark(x2))), natsFrom(z0), x1, tail(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(tail(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__tail(mark(x2))), fst(z0), x1, tail(x2)), A__SPLITAT(mark(fst(z0)), mark(tail(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__tail(mark(x2))), snd(z0), x1, tail(x2)), A__SPLITAT(mark(snd(z0)), mark(tail(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__tail(mark(x2))), splitAt(z0, z1), x1, tail(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(tail(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__tail(mark(x2))), u(z0, z1, z2, z3), x1, tail(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(tail(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__tail(mark(x2))), head(z0), x1, tail(x2)), A__SPLITAT(mark(head(z0)), mark(tail(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__tail(mark(x2))), tail(z0), x1, tail(x2)), A__SPLITAT(mark(tail(z0)), mark(tail(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__tail(mark(x2))), sel(z0, z1), x1, tail(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(tail(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__tail(mark(x2))), afterNth(z0, z1), x1, tail(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(tail(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__tail(mark(x2))), take(z0, z1), x1, tail(x2)), A__SPLITAT(mark(take(z0, z1)), mark(tail(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__tail(mark(x2))), cons(z0, z1), x1, tail(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(tail(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__tail(mark(x2))), s(z0), x1, tail(x2)), A__SPLITAT(mark(s(z0)), mark(tail(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__tail(mark(x2))), pair(z0, z1), x1, tail(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(tail(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(0, a__tail(mark(x2))), 0, x1, tail(x2)), A__SPLITAT(mark(0), mark(tail(x2))))
   A__SPLITAT(s(nil), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(nil, a__tail(mark(x2))), nil, x1, tail(x2)), A__SPLITAT(mark(nil), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(mark(x2)), mark(mark(x3))))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), sel(mark(x2), mark(x3))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__natsFrom(mark(z0)))), x0, x1, sel(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(sel(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__fst(mark(z0)))), x0, x1, sel(x2, fst(z0))), A__SPLITAT(mark(x0), mark(sel(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__snd(mark(z0)))), x0, x1, sel(x2, snd(z0))), A__SPLITAT(mark(x0), mark(sel(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, sel(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, sel(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(sel(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__head(mark(z0)))), x0, x1, sel(x2, head(z0))), A__SPLITAT(mark(x0), mark(sel(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__tail(mark(z0)))), x0, x1, sel(x2, tail(z0))), A__SPLITAT(mark(x0), mark(sel(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, sel(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, sel(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, sel(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), cons(mark(z0), z1))), x0, x1, sel(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), s(mark(z0)))), x0, x1, sel(x2, s(z0))), A__SPLITAT(mark(x0), mark(sel(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, sel(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), 0)), x0, x1, sel(x2, 0)), A__SPLITAT(mark(x0), mark(sel(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), nil)), x0, x1, sel(x2, nil)), A__SPLITAT(mark(x0), mark(sel(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__natsFrom(mark(z0)), mark(x3))), x0, x1, sel(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(sel(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__fst(mark(z0)), mark(x3))), x0, x1, sel(fst(z0), x3)), A__SPLITAT(mark(x0), mark(sel(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__snd(mark(z0)), mark(x3))), x0, x1, sel(snd(z0), x3)), A__SPLITAT(mark(x0), mark(sel(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, sel(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(sel(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__head(mark(z0)), mark(x3))), x0, x1, sel(head(z0), x3)), A__SPLITAT(mark(x0), mark(sel(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__tail(mark(z0)), mark(x3))), x0, x1, sel(tail(z0), x3)), A__SPLITAT(mark(x0), mark(sel(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(cons(mark(z0), z1), mark(x3))), x0, x1, sel(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(s(mark(z0)), mark(x3))), x0, x1, sel(s(z0), x3)), A__SPLITAT(mark(x0), mark(sel(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(0, mark(x3))), x0, x1, sel(0, x3)), A__SPLITAT(mark(x0), mark(sel(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(nil, mark(x3))), x0, x1, sel(nil, x3)), A__SPLITAT(mark(x0), mark(sel(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__sel(mark(x2), mark(x3))), natsFrom(z0), x1, sel(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(sel(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__sel(mark(x2), mark(x3))), fst(z0), x1, sel(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(sel(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__sel(mark(x2), mark(x3))), snd(z0), x1, sel(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(sel(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), splitAt(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(sel(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__sel(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, sel(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(sel(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__sel(mark(x2), mark(x3))), head(z0), x1, sel(x2, x3)), A__SPLITAT(mark(head(z0)), mark(sel(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__sel(mark(x2), mark(x3))), tail(z0), x1, sel(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(sel(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), sel(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(sel(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), afterNth(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(sel(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), take(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(sel(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__sel(mark(x2), mark(x3))), cons(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(sel(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__sel(mark(x2), mark(x3))), s(z0), x1, sel(x2, x3)), A__SPLITAT(mark(s(z0)), mark(sel(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), pair(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(sel(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(0, a__sel(mark(x2), mark(x3))), 0, x1, sel(x2, x3)), A__SPLITAT(mark(0), mark(sel(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(nil, a__sel(mark(x2), mark(x3))), nil, x1, sel(x2, x3)), A__SPLITAT(mark(nil), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(mark(x2)), mark(mark(x3))))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), afterNth(mark(x2), mark(x3))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__natsFrom(mark(z0)))), x0, x1, afterNth(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__fst(mark(z0)))), x0, x1, afterNth(x2, fst(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__snd(mark(z0)))), x0, x1, afterNth(x2, snd(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, afterNth(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, afterNth(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(afterNth(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__head(mark(z0)))), x0, x1, afterNth(x2, head(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__tail(mark(z0)))), x0, x1, afterNth(x2, tail(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, afterNth(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, afterNth(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, afterNth(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), cons(mark(z0), z1))), x0, x1, afterNth(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), s(mark(z0)))), x0, x1, afterNth(x2, s(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, afterNth(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), 0)), x0, x1, afterNth(x2, 0)), A__SPLITAT(mark(x0), mark(afterNth(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), nil)), x0, x1, afterNth(x2, nil)), A__SPLITAT(mark(x0), mark(afterNth(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__natsFrom(mark(z0)), mark(x3))), x0, x1, afterNth(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__fst(mark(z0)), mark(x3))), x0, x1, afterNth(fst(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__snd(mark(z0)), mark(x3))), x0, x1, afterNth(snd(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, afterNth(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(afterNth(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__head(mark(z0)), mark(x3))), x0, x1, afterNth(head(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__tail(mark(z0)), mark(x3))), x0, x1, afterNth(tail(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(cons(mark(z0), z1), mark(x3))), x0, x1, afterNth(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(s(mark(z0)), mark(x3))), x0, x1, afterNth(s(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(0, mark(x3))), x0, x1, afterNth(0, x3)), A__SPLITAT(mark(x0), mark(afterNth(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(nil, mark(x3))), x0, x1, afterNth(nil, x3)), A__SPLITAT(mark(x0), mark(afterNth(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__afterNth(mark(x2), mark(x3))), natsFrom(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(afterNth(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__afterNth(mark(x2), mark(x3))), fst(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(afterNth(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__afterNth(mark(x2), mark(x3))), snd(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(afterNth(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), splitAt(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(afterNth(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__afterNth(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, afterNth(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(afterNth(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__afterNth(mark(x2), mark(x3))), head(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(head(z0)), mark(afterNth(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__afterNth(mark(x2), mark(x3))), tail(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(afterNth(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), sel(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(afterNth(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), afterNth(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(afterNth(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), take(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(afterNth(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__afterNth(mark(x2), mark(x3))), cons(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(afterNth(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__afterNth(mark(x2), mark(x3))), s(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(s(z0)), mark(afterNth(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), pair(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(afterNth(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(afterNth(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(0, a__afterNth(mark(x2), mark(x3))), 0, x1, afterNth(x2, x3)), A__SPLITAT(mark(0), mark(afterNth(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(nil, a__afterNth(mark(x2), mark(x3))), nil, x1, afterNth(x2, x3)), A__SPLITAT(mark(nil), mark(afterNth(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(mark(x2)), mark(mark(x3))))), x0, x1, take(x2, x3)), A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), take(mark(x2), mark(x3))), x0, x1, take(x2, x3)), A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__natsFrom(mark(z0)))), x0, x1, take(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(take(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__fst(mark(z0)))), x0, x1, take(x2, fst(z0))), A__SPLITAT(mark(x0), mark(take(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__snd(mark(z0)))), x0, x1, take(x2, snd(z0))), A__SPLITAT(mark(x0), mark(take(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, take(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, take(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(take(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__head(mark(z0)))), x0, x1, take(x2, head(z0))), A__SPLITAT(mark(x0), mark(take(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__tail(mark(z0)))), x0, x1, take(x2, tail(z0))), A__SPLITAT(mark(x0), mark(take(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, take(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, take(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, take(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), cons(mark(z0), z1))), x0, x1, take(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), s(mark(z0)))), x0, x1, take(x2, s(z0))), A__SPLITAT(mark(x0), mark(take(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, take(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), 0)), x0, x1, take(x2, 0)), A__SPLITAT(mark(x0), mark(take(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), nil)), x0, x1, take(x2, nil)), A__SPLITAT(mark(x0), mark(take(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__natsFrom(mark(z0)), mark(x3))), x0, x1, take(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(take(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__fst(mark(z0)), mark(x3))), x0, x1, take(fst(z0), x3)), A__SPLITAT(mark(x0), mark(take(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__snd(mark(z0)), mark(x3))), x0, x1, take(snd(z0), x3)), A__SPLITAT(mark(x0), mark(take(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, take(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, take(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(take(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__head(mark(z0)), mark(x3))), x0, x1, take(head(z0), x3)), A__SPLITAT(mark(x0), mark(take(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__tail(mark(z0)), mark(x3))), x0, x1, take(tail(z0), x3)), A__SPLITAT(mark(x0), mark(take(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, take(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, take(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, take(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(cons(mark(z0), z1), mark(x3))), x0, x1, take(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(s(mark(z0)), mark(x3))), x0, x1, take(s(z0), x3)), A__SPLITAT(mark(x0), mark(take(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, take(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(0, mark(x3))), x0, x1, take(0, x3)), A__SPLITAT(mark(x0), mark(take(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(nil, mark(x3))), x0, x1, take(nil, x3)), A__SPLITAT(mark(x0), mark(take(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__take(mark(x2), mark(x3))), natsFrom(z0), x1, take(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(take(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__take(mark(x2), mark(x3))), fst(z0), x1, take(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(take(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__take(mark(x2), mark(x3))), snd(z0), x1, take(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(take(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), splitAt(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(take(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__take(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, take(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(take(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__take(mark(x2), mark(x3))), head(z0), x1, take(x2, x3)), A__SPLITAT(mark(head(z0)), mark(take(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__take(mark(x2), mark(x3))), tail(z0), x1, take(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(take(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), sel(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(take(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), afterNth(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(take(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), take(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(take(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__take(mark(x2), mark(x3))), cons(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(take(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__take(mark(x2), mark(x3))), s(z0), x1, take(x2, x3)), A__SPLITAT(mark(s(z0)), mark(take(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), pair(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(take(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(take(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(0, a__take(mark(x2), mark(x3))), 0, x1, take(x2, x3)), A__SPLITAT(mark(0), mark(take(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(nil, a__take(mark(x2), mark(x3))), nil, x1, take(x2, x3)), A__SPLITAT(mark(nil), mark(take(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, cons(x2, x3))) -> c7(A__U(splitAt(mark(x0), cons(mark(x2), x3)), x0, x1, cons(x2, x3)), A__SPLITAT(mark(x0), mark(cons(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__natsFrom(mark(z0)), x3)), x0, x1, cons(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(cons(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__fst(mark(z0)), x3)), x0, x1, cons(fst(z0), x3)), A__SPLITAT(mark(x0), mark(cons(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__snd(mark(z0)), x3)), x0, x1, cons(snd(z0), x3)), A__SPLITAT(mark(x0), mark(cons(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__splitAt(mark(z0), mark(z1)), x3)), x0, x1, cons(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__u(mark(z0), z1, z2, z3), x3)), x0, x1, cons(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(cons(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__head(mark(z0)), x3)), x0, x1, cons(head(z0), x3)), A__SPLITAT(mark(x0), mark(cons(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__tail(mark(z0)), x3)), x0, x1, cons(tail(z0), x3)), A__SPLITAT(mark(x0), mark(cons(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__sel(mark(z0), mark(z1)), x3)), x0, x1, cons(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__afterNth(mark(z0), mark(z1)), x3)), x0, x1, cons(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__take(mark(z0), mark(z1)), x3)), x0, x1, cons(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(cons(mark(z0), z1), x3)), x0, x1, cons(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(s(mark(z0)), x3)), x0, x1, cons(s(z0), x3)), A__SPLITAT(mark(x0), mark(cons(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(pair(mark(z0), mark(z1)), x3)), x0, x1, cons(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(0, x3))) -> c7(A__U(a__splitAt(mark(x0), cons(0, x3)), x0, x1, cons(0, x3)), A__SPLITAT(mark(x0), mark(cons(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), cons(nil, x3)), x0, x1, cons(nil, x3)), A__SPLITAT(mark(x0), mark(cons(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), cons(mark(x2), x3)), natsFrom(z0), x1, cons(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(cons(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), cons(mark(x2), x3)), fst(z0), x1, cons(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(cons(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), cons(mark(x2), x3)), snd(z0), x1, cons(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(cons(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), cons(mark(x2), x3)), splitAt(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(cons(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), cons(mark(x2), x3)), u(z0, z1, z2, z3), x1, cons(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(cons(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), cons(mark(x2), x3)), head(z0), x1, cons(x2, x3)), A__SPLITAT(mark(head(z0)), mark(cons(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), cons(mark(x2), x3)), tail(z0), x1, cons(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(cons(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), cons(mark(x2), x3)), sel(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(cons(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), cons(mark(x2), x3)), afterNth(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(cons(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), cons(mark(x2), x3)), take(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(cons(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), cons(mark(x2), x3)), cons(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(cons(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), cons(mark(x2), x3)), s(z0), x1, cons(x2, x3)), A__SPLITAT(mark(s(z0)), mark(cons(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), cons(mark(x2), x3)), pair(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(cons(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(0, cons(mark(x2), x3)), 0, x1, cons(x2, x3)), A__SPLITAT(mark(0), mark(cons(x2, x3))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(nil, cons(mark(x2), x3)), nil, x1, cons(x2, x3)), A__SPLITAT(mark(nil), mark(cons(x2, x3))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, cons(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(cons(x2, x3))))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(mark(x0), head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__natsFrom(mark(z0)))), x0, x1, head(natsFrom(z0))), A__SPLITAT(mark(x0), mark(head(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__fst(mark(z0)))), x0, x1, head(fst(z0))), A__SPLITAT(mark(x0), mark(head(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__snd(mark(z0)))), x0, x1, head(snd(z0))), A__SPLITAT(mark(x0), mark(head(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__splitAt(mark(z0), mark(z1)))), x0, x1, head(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(head(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__u(mark(z0), z1, z2, z3))), x0, x1, head(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(head(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__head(mark(z0)))), x0, x1, head(head(z0))), A__SPLITAT(mark(x0), mark(head(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__tail(mark(z0)))), x0, x1, head(tail(z0))), A__SPLITAT(mark(x0), mark(head(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__sel(mark(z0), mark(z1)))), x0, x1, head(sel(z0, z1))), A__SPLITAT(mark(x0), mark(head(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(z0), mark(z1)))), x0, x1, head(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(head(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__take(mark(z0), mark(z1)))), x0, x1, head(take(z0, z1))), A__SPLITAT(mark(x0), mark(head(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(cons(mark(z0), z1))), x0, x1, head(cons(z0, z1))), A__SPLITAT(mark(x0), mark(head(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(s(mark(z0)))), x0, x1, head(s(z0))), A__SPLITAT(mark(x0), mark(head(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(pair(mark(z0), mark(z1)))), x0, x1, head(pair(z0, z1))), A__SPLITAT(mark(x0), mark(head(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(0))) -> c7(A__U(a__splitAt(mark(x0), a__head(0)), x0, x1, head(0)), A__SPLITAT(mark(x0), mark(head(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(nil))) -> c7(A__U(a__splitAt(mark(x0), a__head(nil)), x0, x1, head(nil)), A__SPLITAT(mark(x0), mark(head(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__head(mark(x2))), natsFrom(z0), x1, head(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(head(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__head(mark(x2))), fst(z0), x1, head(x2)), A__SPLITAT(mark(fst(z0)), mark(head(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__head(mark(x2))), snd(z0), x1, head(x2)), A__SPLITAT(mark(snd(z0)), mark(head(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__head(mark(x2))), splitAt(z0, z1), x1, head(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(head(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__head(mark(x2))), u(z0, z1, z2, z3), x1, head(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(head(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__head(mark(x2))), head(z0), x1, head(x2)), A__SPLITAT(mark(head(z0)), mark(head(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__head(mark(x2))), tail(z0), x1, head(x2)), A__SPLITAT(mark(tail(z0)), mark(head(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__head(mark(x2))), sel(z0, z1), x1, head(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(head(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__head(mark(x2))), afterNth(z0, z1), x1, head(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(head(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__head(mark(x2))), take(z0, z1), x1, head(x2)), A__SPLITAT(mark(take(z0, z1)), mark(head(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__head(mark(x2))), cons(z0, z1), x1, head(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(head(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__head(mark(x2))), s(z0), x1, head(x2)), A__SPLITAT(mark(s(z0)), mark(head(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__head(mark(x2))), pair(z0, z1), x1, head(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(head(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(0, a__head(mark(x2))), 0, x1, head(x2)), A__SPLITAT(mark(0), mark(head(x2))))
   A__SPLITAT(s(nil), cons(x1, head(x2))) -> c7(A__U(a__splitAt(nil, a__head(mark(x2))), nil, x1, head(x2)), A__SPLITAT(mark(nil), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(mark(x0), tail(mark(x2))), x0, x1, tail(x2)), A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__natsFrom(mark(z0)))), x0, x1, tail(natsFrom(z0))), A__SPLITAT(mark(x0), mark(tail(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__fst(mark(z0)))), x0, x1, tail(fst(z0))), A__SPLITAT(mark(x0), mark(tail(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__snd(mark(z0)))), x0, x1, tail(snd(z0))), A__SPLITAT(mark(x0), mark(tail(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__splitAt(mark(z0), mark(z1)))), x0, x1, tail(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(tail(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__u(mark(z0), z1, z2, z3))), x0, x1, tail(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(tail(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__head(mark(z0)))), x0, x1, tail(head(z0))), A__SPLITAT(mark(x0), mark(tail(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__tail(mark(z0)))), x0, x1, tail(tail(z0))), A__SPLITAT(mark(x0), mark(tail(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__sel(mark(z0), mark(z1)))), x0, x1, tail(sel(z0, z1))), A__SPLITAT(mark(x0), mark(tail(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__afterNth(mark(z0), mark(z1)))), x0, x1, tail(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(tail(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__take(mark(z0), mark(z1)))), x0, x1, tail(take(z0, z1))), A__SPLITAT(mark(x0), mark(tail(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(cons(mark(z0), z1))), x0, x1, tail(cons(z0, z1))), A__SPLITAT(mark(x0), mark(tail(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(s(mark(z0)))), x0, x1, tail(s(z0))), A__SPLITAT(mark(x0), mark(tail(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(pair(mark(z0), mark(z1)))), x0, x1, tail(pair(z0, z1))), A__SPLITAT(mark(x0), mark(tail(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(0)), x0, x1, tail(0)), A__SPLITAT(mark(x0), mark(tail(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(nil))) -> c7(A__U(a__splitAt(mark(x0), a__tail(nil)), x0, x1, tail(nil)), A__SPLITAT(mark(x0), mark(tail(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__tail(mark(x2))), natsFrom(z0), x1, tail(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(tail(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__tail(mark(x2))), fst(z0), x1, tail(x2)), A__SPLITAT(mark(fst(z0)), mark(tail(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__tail(mark(x2))), snd(z0), x1, tail(x2)), A__SPLITAT(mark(snd(z0)), mark(tail(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__tail(mark(x2))), splitAt(z0, z1), x1, tail(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(tail(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__tail(mark(x2))), u(z0, z1, z2, z3), x1, tail(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(tail(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__tail(mark(x2))), head(z0), x1, tail(x2)), A__SPLITAT(mark(head(z0)), mark(tail(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__tail(mark(x2))), tail(z0), x1, tail(x2)), A__SPLITAT(mark(tail(z0)), mark(tail(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__tail(mark(x2))), sel(z0, z1), x1, tail(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(tail(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__tail(mark(x2))), afterNth(z0, z1), x1, tail(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(tail(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__tail(mark(x2))), take(z0, z1), x1, tail(x2)), A__SPLITAT(mark(take(z0, z1)), mark(tail(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__tail(mark(x2))), cons(z0, z1), x1, tail(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(tail(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__tail(mark(x2))), s(z0), x1, tail(x2)), A__SPLITAT(mark(s(z0)), mark(tail(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__tail(mark(x2))), pair(z0, z1), x1, tail(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(tail(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(0, a__tail(mark(x2))), 0, x1, tail(x2)), A__SPLITAT(mark(0), mark(tail(x2))))
   A__SPLITAT(s(nil), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(nil, a__tail(mark(x2))), nil, x1, tail(x2)), A__SPLITAT(mark(nil), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(mark(x2)), mark(mark(x3))))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), sel(mark(x2), mark(x3))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__natsFrom(mark(z0)))), x0, x1, sel(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(sel(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__fst(mark(z0)))), x0, x1, sel(x2, fst(z0))), A__SPLITAT(mark(x0), mark(sel(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__snd(mark(z0)))), x0, x1, sel(x2, snd(z0))), A__SPLITAT(mark(x0), mark(sel(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, sel(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, sel(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(sel(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__head(mark(z0)))), x0, x1, sel(x2, head(z0))), A__SPLITAT(mark(x0), mark(sel(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__tail(mark(z0)))), x0, x1, sel(x2, tail(z0))), A__SPLITAT(mark(x0), mark(sel(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, sel(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, sel(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, sel(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), cons(mark(z0), z1))), x0, x1, sel(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), s(mark(z0)))), x0, x1, sel(x2, s(z0))), A__SPLITAT(mark(x0), mark(sel(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, sel(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), 0)), x0, x1, sel(x2, 0)), A__SPLITAT(mark(x0), mark(sel(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), nil)), x0, x1, sel(x2, nil)), A__SPLITAT(mark(x0), mark(sel(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__natsFrom(mark(z0)), mark(x3))), x0, x1, sel(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(sel(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__fst(mark(z0)), mark(x3))), x0, x1, sel(fst(z0), x3)), A__SPLITAT(mark(x0), mark(sel(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__snd(mark(z0)), mark(x3))), x0, x1, sel(snd(z0), x3)), A__SPLITAT(mark(x0), mark(sel(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, sel(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(sel(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__head(mark(z0)), mark(x3))), x0, x1, sel(head(z0), x3)), A__SPLITAT(mark(x0), mark(sel(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__tail(mark(z0)), mark(x3))), x0, x1, sel(tail(z0), x3)), A__SPLITAT(mark(x0), mark(sel(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(cons(mark(z0), z1), mark(x3))), x0, x1, sel(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(s(mark(z0)), mark(x3))), x0, x1, sel(s(z0), x3)), A__SPLITAT(mark(x0), mark(sel(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(0, mark(x3))), x0, x1, sel(0, x3)), A__SPLITAT(mark(x0), mark(sel(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(nil, mark(x3))), x0, x1, sel(nil, x3)), A__SPLITAT(mark(x0), mark(sel(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__sel(mark(x2), mark(x3))), natsFrom(z0), x1, sel(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(sel(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__sel(mark(x2), mark(x3))), fst(z0), x1, sel(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(sel(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__sel(mark(x2), mark(x3))), snd(z0), x1, sel(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(sel(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), splitAt(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(sel(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__sel(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, sel(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(sel(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__sel(mark(x2), mark(x3))), head(z0), x1, sel(x2, x3)), A__SPLITAT(mark(head(z0)), mark(sel(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__sel(mark(x2), mark(x3))), tail(z0), x1, sel(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(sel(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), sel(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(sel(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), afterNth(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(sel(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), take(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(sel(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__sel(mark(x2), mark(x3))), cons(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(sel(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__sel(mark(x2), mark(x3))), s(z0), x1, sel(x2, x3)), A__SPLITAT(mark(s(z0)), mark(sel(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), pair(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(sel(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(0, a__sel(mark(x2), mark(x3))), 0, x1, sel(x2, x3)), A__SPLITAT(mark(0), mark(sel(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(nil, a__sel(mark(x2), mark(x3))), nil, x1, sel(x2, x3)), A__SPLITAT(mark(nil), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(mark(x2)), mark(mark(x3))))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), afterNth(mark(x2), mark(x3))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__natsFrom(mark(z0)))), x0, x1, afterNth(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__fst(mark(z0)))), x0, x1, afterNth(x2, fst(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__snd(mark(z0)))), x0, x1, afterNth(x2, snd(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, afterNth(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, afterNth(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(afterNth(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__head(mark(z0)))), x0, x1, afterNth(x2, head(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__tail(mark(z0)))), x0, x1, afterNth(x2, tail(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, afterNth(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, afterNth(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, afterNth(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), cons(mark(z0), z1))), x0, x1, afterNth(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), s(mark(z0)))), x0, x1, afterNth(x2, s(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, afterNth(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), 0)), x0, x1, afterNth(x2, 0)), A__SPLITAT(mark(x0), mark(afterNth(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), nil)), x0, x1, afterNth(x2, nil)), A__SPLITAT(mark(x0), mark(afterNth(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__natsFrom(mark(z0)), mark(x3))), x0, x1, afterNth(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__fst(mark(z0)), mark(x3))), x0, x1, afterNth(fst(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__snd(mark(z0)), mark(x3))), x0, x1, afterNth(snd(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, afterNth(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(afterNth(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__head(mark(z0)), mark(x3))), x0, x1, afterNth(head(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__tail(mark(z0)), mark(x3))), x0, x1, afterNth(tail(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(cons(mark(z0), z1), mark(x3))), x0, x1, afterNth(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(s(mark(z0)), mark(x3))), x0, x1, afterNth(s(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(0, mark(x3))), x0, x1, afterNth(0, x3)), A__SPLITAT(mark(x0), mark(afterNth(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(nil, mark(x3))), x0, x1, afterNth(nil, x3)), A__SPLITAT(mark(x0), mark(afterNth(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__afterNth(mark(x2), mark(x3))), natsFrom(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(afterNth(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__afterNth(mark(x2), mark(x3))), fst(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(afterNth(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__afterNth(mark(x2), mark(x3))), snd(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(afterNth(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), splitAt(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(afterNth(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__afterNth(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, afterNth(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(afterNth(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__afterNth(mark(x2), mark(x3))), head(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(head(z0)), mark(afterNth(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__afterNth(mark(x2), mark(x3))), tail(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(afterNth(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), sel(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(afterNth(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), afterNth(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(afterNth(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), take(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(afterNth(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__afterNth(mark(x2), mark(x3))), cons(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(afterNth(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__afterNth(mark(x2), mark(x3))), s(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(s(z0)), mark(afterNth(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), pair(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(afterNth(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(afterNth(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(0, a__afterNth(mark(x2), mark(x3))), 0, x1, afterNth(x2, x3)), A__SPLITAT(mark(0), mark(afterNth(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(nil, a__afterNth(mark(x2), mark(x3))), nil, x1, afterNth(x2, x3)), A__SPLITAT(mark(nil), mark(afterNth(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(mark(x2)), mark(mark(x3))))), x0, x1, take(x2, x3)), A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), take(mark(x2), mark(x3))), x0, x1, take(x2, x3)), A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__natsFrom(mark(z0)))), x0, x1, take(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(take(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__fst(mark(z0)))), x0, x1, take(x2, fst(z0))), A__SPLITAT(mark(x0), mark(take(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__snd(mark(z0)))), x0, x1, take(x2, snd(z0))), A__SPLITAT(mark(x0), mark(take(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, take(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, take(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(take(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__head(mark(z0)))), x0, x1, take(x2, head(z0))), A__SPLITAT(mark(x0), mark(take(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__tail(mark(z0)))), x0, x1, take(x2, tail(z0))), A__SPLITAT(mark(x0), mark(take(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, take(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, take(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, take(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), cons(mark(z0), z1))), x0, x1, take(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), s(mark(z0)))), x0, x1, take(x2, s(z0))), A__SPLITAT(mark(x0), mark(take(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, take(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), 0)), x0, x1, take(x2, 0)), A__SPLITAT(mark(x0), mark(take(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), nil)), x0, x1, take(x2, nil)), A__SPLITAT(mark(x0), mark(take(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__natsFrom(mark(z0)), mark(x3))), x0, x1, take(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(take(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__fst(mark(z0)), mark(x3))), x0, x1, take(fst(z0), x3)), A__SPLITAT(mark(x0), mark(take(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__snd(mark(z0)), mark(x3))), x0, x1, take(snd(z0), x3)), A__SPLITAT(mark(x0), mark(take(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, take(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, take(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(take(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__head(mark(z0)), mark(x3))), x0, x1, take(head(z0), x3)), A__SPLITAT(mark(x0), mark(take(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__tail(mark(z0)), mark(x3))), x0, x1, take(tail(z0), x3)), A__SPLITAT(mark(x0), mark(take(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, take(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, take(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, take(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(cons(mark(z0), z1), mark(x3))), x0, x1, take(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(s(mark(z0)), mark(x3))), x0, x1, take(s(z0), x3)), A__SPLITAT(mark(x0), mark(take(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, take(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(0, mark(x3))), x0, x1, take(0, x3)), A__SPLITAT(mark(x0), mark(take(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(nil, mark(x3))), x0, x1, take(nil, x3)), A__SPLITAT(mark(x0), mark(take(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__take(mark(x2), mark(x3))), natsFrom(z0), x1, take(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(take(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__take(mark(x2), mark(x3))), fst(z0), x1, take(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(take(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__take(mark(x2), mark(x3))), snd(z0), x1, take(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(take(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), splitAt(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(take(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__take(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, take(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(take(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__take(mark(x2), mark(x3))), head(z0), x1, take(x2, x3)), A__SPLITAT(mark(head(z0)), mark(take(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__take(mark(x2), mark(x3))), tail(z0), x1, take(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(take(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), sel(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(take(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), afterNth(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(take(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), take(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(take(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__take(mark(x2), mark(x3))), cons(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(take(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__take(mark(x2), mark(x3))), s(z0), x1, take(x2, x3)), A__SPLITAT(mark(s(z0)), mark(take(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), pair(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(take(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(take(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(0, a__take(mark(x2), mark(x3))), 0, x1, take(x2, x3)), A__SPLITAT(mark(0), mark(take(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(nil, a__take(mark(x2), mark(x3))), nil, x1, take(x2, x3)), A__SPLITAT(mark(nil), mark(take(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, cons(x2, x3))) -> c7(A__U(splitAt(mark(x0), cons(mark(x2), x3)), x0, x1, cons(x2, x3)), A__SPLITAT(mark(x0), mark(cons(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__natsFrom(mark(z0)), x3)), x0, x1, cons(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(cons(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__fst(mark(z0)), x3)), x0, x1, cons(fst(z0), x3)), A__SPLITAT(mark(x0), mark(cons(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__snd(mark(z0)), x3)), x0, x1, cons(snd(z0), x3)), A__SPLITAT(mark(x0), mark(cons(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__splitAt(mark(z0), mark(z1)), x3)), x0, x1, cons(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__u(mark(z0), z1, z2, z3), x3)), x0, x1, cons(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(cons(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__head(mark(z0)), x3)), x0, x1, cons(head(z0), x3)), A__SPLITAT(mark(x0), mark(cons(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__tail(mark(z0)), x3)), x0, x1, cons(tail(z0), x3)), A__SPLITAT(mark(x0), mark(cons(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__sel(mark(z0), mark(z1)), x3)), x0, x1, cons(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__afterNth(mark(z0), mark(z1)), x3)), x0, x1, cons(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__take(mark(z0), mark(z1)), x3)), x0, x1, cons(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(cons(mark(z0), z1), x3)), x0, x1, cons(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(s(mark(z0)), x3)), x0, x1, cons(s(z0), x3)), A__SPLITAT(mark(x0), mark(cons(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(pair(mark(z0), mark(z1)), x3)), x0, x1, cons(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(0, x3))) -> c7(A__U(a__splitAt(mark(x0), cons(0, x3)), x0, x1, cons(0, x3)), A__SPLITAT(mark(x0), mark(cons(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), cons(nil, x3)), x0, x1, cons(nil, x3)), A__SPLITAT(mark(x0), mark(cons(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), cons(mark(x2), x3)), natsFrom(z0), x1, cons(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(cons(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), cons(mark(x2), x3)), fst(z0), x1, cons(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(cons(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), cons(mark(x2), x3)), snd(z0), x1, cons(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(cons(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), cons(mark(x2), x3)), splitAt(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(cons(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), cons(mark(x2), x3)), u(z0, z1, z2, z3), x1, cons(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(cons(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), cons(mark(x2), x3)), head(z0), x1, cons(x2, x3)), A__SPLITAT(mark(head(z0)), mark(cons(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), cons(mark(x2), x3)), tail(z0), x1, cons(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(cons(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), cons(mark(x2), x3)), sel(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(cons(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), cons(mark(x2), x3)), afterNth(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(cons(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), cons(mark(x2), x3)), take(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(cons(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), cons(mark(x2), x3)), cons(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(cons(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), cons(mark(x2), x3)), s(z0), x1, cons(x2, x3)), A__SPLITAT(mark(s(z0)), mark(cons(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), cons(mark(x2), x3)), pair(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(cons(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(0), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(0, cons(mark(x2), x3)), 0, x1, cons(x2, x3)), A__SPLITAT(mark(0), mark(cons(x2, x3))), MARK(0))
   A__SPLITAT(s(nil), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(nil, cons(mark(x2), x3)), nil, x1, cons(x2, x3)), A__SPLITAT(mark(nil), mark(cons(x2, x3))), MARK(nil))
   A__SPLITAT(s(x0), cons(x1, cons(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(cons(x2, x3))))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1, c33_2, c33_1, c7_1


----------------------------------------

(167) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 3 trailing tuple parts
----------------------------------------

(168)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   a__natsFrom(z0) -> cons(mark(z0), natsFrom(s(z0)))
   a__natsFrom(z0) -> natsFrom(z0)
   a__fst(pair(z0, z1)) -> mark(z0)
   a__fst(z0) -> fst(z0)
   a__snd(pair(z0, z1)) -> mark(z1)
   a__snd(z0) -> snd(z0)
   a__splitAt(0, z0) -> pair(nil, mark(z0))
   a__splitAt(s(z0), cons(z1, z2)) -> a__u(a__splitAt(mark(z0), mark(z2)), z0, z1, z2)
   a__splitAt(z0, z1) -> splitAt(z0, z1)
   a__u(pair(z0, z1), z2, z3, z4) -> pair(cons(mark(z3), z0), mark(z1))
   a__u(z0, z1, z2, z3) -> u(z0, z1, z2, z3)
   a__head(cons(z0, z1)) -> mark(z0)
   a__head(z0) -> head(z0)
   a__tail(cons(z0, z1)) -> mark(z1)
   a__tail(z0) -> tail(z0)
   a__sel(z0, z1) -> a__head(a__afterNth(mark(z0), mark(z1)))
   a__sel(z0, z1) -> sel(z0, z1)
   a__take(z0, z1) -> a__fst(a__splitAt(mark(z0), mark(z1)))
   a__take(z0, z1) -> take(z0, z1)
   a__afterNth(z0, z1) -> a__snd(a__splitAt(mark(z0), mark(z1)))
   a__afterNth(z0, z1) -> afterNth(z0, z1)
   mark(natsFrom(z0)) -> a__natsFrom(mark(z0))
   mark(fst(z0)) -> a__fst(mark(z0))
   mark(snd(z0)) -> a__snd(mark(z0))
   mark(splitAt(z0, z1)) -> a__splitAt(mark(z0), mark(z1))
   mark(u(z0, z1, z2, z3)) -> a__u(mark(z0), z1, z2, z3)
   mark(head(z0)) -> a__head(mark(z0))
   mark(tail(z0)) -> a__tail(mark(z0))
   mark(sel(z0, z1)) -> a__sel(mark(z0), mark(z1))
   mark(afterNth(z0, z1)) -> a__afterNth(mark(z0), mark(z1))
   mark(take(z0, z1)) -> a__take(mark(z0), mark(z1))
   mark(cons(z0, z1)) -> cons(mark(z0), z1)
   mark(s(z0)) -> s(mark(z0))
   mark(pair(z0, z1)) -> pair(mark(z0), mark(z1))
   mark(0) -> 0
   mark(nil) -> nil
Tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(mark(x0), head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__natsFrom(mark(z0)))), x0, x1, head(natsFrom(z0))), A__SPLITAT(mark(x0), mark(head(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__fst(mark(z0)))), x0, x1, head(fst(z0))), A__SPLITAT(mark(x0), mark(head(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__snd(mark(z0)))), x0, x1, head(snd(z0))), A__SPLITAT(mark(x0), mark(head(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__splitAt(mark(z0), mark(z1)))), x0, x1, head(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(head(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__u(mark(z0), z1, z2, z3))), x0, x1, head(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(head(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__head(mark(z0)))), x0, x1, head(head(z0))), A__SPLITAT(mark(x0), mark(head(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__tail(mark(z0)))), x0, x1, head(tail(z0))), A__SPLITAT(mark(x0), mark(head(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__sel(mark(z0), mark(z1)))), x0, x1, head(sel(z0, z1))), A__SPLITAT(mark(x0), mark(head(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(z0), mark(z1)))), x0, x1, head(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(head(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__take(mark(z0), mark(z1)))), x0, x1, head(take(z0, z1))), A__SPLITAT(mark(x0), mark(head(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(cons(mark(z0), z1))), x0, x1, head(cons(z0, z1))), A__SPLITAT(mark(x0), mark(head(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(s(mark(z0)))), x0, x1, head(s(z0))), A__SPLITAT(mark(x0), mark(head(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(pair(mark(z0), mark(z1)))), x0, x1, head(pair(z0, z1))), A__SPLITAT(mark(x0), mark(head(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(0))) -> c7(A__U(a__splitAt(mark(x0), a__head(0)), x0, x1, head(0)), A__SPLITAT(mark(x0), mark(head(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(nil))) -> c7(A__U(a__splitAt(mark(x0), a__head(nil)), x0, x1, head(nil)), A__SPLITAT(mark(x0), mark(head(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__head(mark(x2))), natsFrom(z0), x1, head(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(head(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__head(mark(x2))), fst(z0), x1, head(x2)), A__SPLITAT(mark(fst(z0)), mark(head(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__head(mark(x2))), snd(z0), x1, head(x2)), A__SPLITAT(mark(snd(z0)), mark(head(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__head(mark(x2))), splitAt(z0, z1), x1, head(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(head(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__head(mark(x2))), u(z0, z1, z2, z3), x1, head(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(head(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__head(mark(x2))), head(z0), x1, head(x2)), A__SPLITAT(mark(head(z0)), mark(head(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__head(mark(x2))), tail(z0), x1, head(x2)), A__SPLITAT(mark(tail(z0)), mark(head(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__head(mark(x2))), sel(z0, z1), x1, head(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(head(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__head(mark(x2))), afterNth(z0, z1), x1, head(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(head(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__head(mark(x2))), take(z0, z1), x1, head(x2)), A__SPLITAT(mark(take(z0, z1)), mark(head(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__head(mark(x2))), cons(z0, z1), x1, head(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(head(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__head(mark(x2))), s(z0), x1, head(x2)), A__SPLITAT(mark(s(z0)), mark(head(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__head(mark(x2))), pair(z0, z1), x1, head(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(head(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(0, a__head(mark(x2))), 0, x1, head(x2)), A__SPLITAT(mark(0), mark(head(x2))))
   A__SPLITAT(s(nil), cons(x1, head(x2))) -> c7(A__U(a__splitAt(nil, a__head(mark(x2))), nil, x1, head(x2)), A__SPLITAT(mark(nil), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(mark(x0), tail(mark(x2))), x0, x1, tail(x2)), A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__natsFrom(mark(z0)))), x0, x1, tail(natsFrom(z0))), A__SPLITAT(mark(x0), mark(tail(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__fst(mark(z0)))), x0, x1, tail(fst(z0))), A__SPLITAT(mark(x0), mark(tail(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__snd(mark(z0)))), x0, x1, tail(snd(z0))), A__SPLITAT(mark(x0), mark(tail(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__splitAt(mark(z0), mark(z1)))), x0, x1, tail(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(tail(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__u(mark(z0), z1, z2, z3))), x0, x1, tail(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(tail(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__head(mark(z0)))), x0, x1, tail(head(z0))), A__SPLITAT(mark(x0), mark(tail(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__tail(mark(z0)))), x0, x1, tail(tail(z0))), A__SPLITAT(mark(x0), mark(tail(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__sel(mark(z0), mark(z1)))), x0, x1, tail(sel(z0, z1))), A__SPLITAT(mark(x0), mark(tail(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__afterNth(mark(z0), mark(z1)))), x0, x1, tail(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(tail(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__take(mark(z0), mark(z1)))), x0, x1, tail(take(z0, z1))), A__SPLITAT(mark(x0), mark(tail(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(cons(mark(z0), z1))), x0, x1, tail(cons(z0, z1))), A__SPLITAT(mark(x0), mark(tail(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(s(mark(z0)))), x0, x1, tail(s(z0))), A__SPLITAT(mark(x0), mark(tail(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(pair(mark(z0), mark(z1)))), x0, x1, tail(pair(z0, z1))), A__SPLITAT(mark(x0), mark(tail(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(0)), x0, x1, tail(0)), A__SPLITAT(mark(x0), mark(tail(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(nil))) -> c7(A__U(a__splitAt(mark(x0), a__tail(nil)), x0, x1, tail(nil)), A__SPLITAT(mark(x0), mark(tail(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__tail(mark(x2))), natsFrom(z0), x1, tail(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(tail(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__tail(mark(x2))), fst(z0), x1, tail(x2)), A__SPLITAT(mark(fst(z0)), mark(tail(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__tail(mark(x2))), snd(z0), x1, tail(x2)), A__SPLITAT(mark(snd(z0)), mark(tail(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__tail(mark(x2))), splitAt(z0, z1), x1, tail(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(tail(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__tail(mark(x2))), u(z0, z1, z2, z3), x1, tail(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(tail(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__tail(mark(x2))), head(z0), x1, tail(x2)), A__SPLITAT(mark(head(z0)), mark(tail(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__tail(mark(x2))), tail(z0), x1, tail(x2)), A__SPLITAT(mark(tail(z0)), mark(tail(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__tail(mark(x2))), sel(z0, z1), x1, tail(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(tail(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__tail(mark(x2))), afterNth(z0, z1), x1, tail(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(tail(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__tail(mark(x2))), take(z0, z1), x1, tail(x2)), A__SPLITAT(mark(take(z0, z1)), mark(tail(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__tail(mark(x2))), cons(z0, z1), x1, tail(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(tail(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__tail(mark(x2))), s(z0), x1, tail(x2)), A__SPLITAT(mark(s(z0)), mark(tail(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__tail(mark(x2))), pair(z0, z1), x1, tail(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(tail(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(0, a__tail(mark(x2))), 0, x1, tail(x2)), A__SPLITAT(mark(0), mark(tail(x2))))
   A__SPLITAT(s(nil), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(nil, a__tail(mark(x2))), nil, x1, tail(x2)), A__SPLITAT(mark(nil), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(mark(x2)), mark(mark(x3))))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), sel(mark(x2), mark(x3))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__natsFrom(mark(z0)))), x0, x1, sel(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(sel(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__fst(mark(z0)))), x0, x1, sel(x2, fst(z0))), A__SPLITAT(mark(x0), mark(sel(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__snd(mark(z0)))), x0, x1, sel(x2, snd(z0))), A__SPLITAT(mark(x0), mark(sel(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, sel(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, sel(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(sel(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__head(mark(z0)))), x0, x1, sel(x2, head(z0))), A__SPLITAT(mark(x0), mark(sel(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__tail(mark(z0)))), x0, x1, sel(x2, tail(z0))), A__SPLITAT(mark(x0), mark(sel(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, sel(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, sel(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, sel(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), cons(mark(z0), z1))), x0, x1, sel(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), s(mark(z0)))), x0, x1, sel(x2, s(z0))), A__SPLITAT(mark(x0), mark(sel(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, sel(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), 0)), x0, x1, sel(x2, 0)), A__SPLITAT(mark(x0), mark(sel(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), nil)), x0, x1, sel(x2, nil)), A__SPLITAT(mark(x0), mark(sel(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__natsFrom(mark(z0)), mark(x3))), x0, x1, sel(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(sel(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__fst(mark(z0)), mark(x3))), x0, x1, sel(fst(z0), x3)), A__SPLITAT(mark(x0), mark(sel(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__snd(mark(z0)), mark(x3))), x0, x1, sel(snd(z0), x3)), A__SPLITAT(mark(x0), mark(sel(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, sel(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(sel(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__head(mark(z0)), mark(x3))), x0, x1, sel(head(z0), x3)), A__SPLITAT(mark(x0), mark(sel(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__tail(mark(z0)), mark(x3))), x0, x1, sel(tail(z0), x3)), A__SPLITAT(mark(x0), mark(sel(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(cons(mark(z0), z1), mark(x3))), x0, x1, sel(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(s(mark(z0)), mark(x3))), x0, x1, sel(s(z0), x3)), A__SPLITAT(mark(x0), mark(sel(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(0, mark(x3))), x0, x1, sel(0, x3)), A__SPLITAT(mark(x0), mark(sel(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(nil, mark(x3))), x0, x1, sel(nil, x3)), A__SPLITAT(mark(x0), mark(sel(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__sel(mark(x2), mark(x3))), natsFrom(z0), x1, sel(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(sel(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__sel(mark(x2), mark(x3))), fst(z0), x1, sel(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(sel(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__sel(mark(x2), mark(x3))), snd(z0), x1, sel(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(sel(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), splitAt(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(sel(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__sel(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, sel(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(sel(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__sel(mark(x2), mark(x3))), head(z0), x1, sel(x2, x3)), A__SPLITAT(mark(head(z0)), mark(sel(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__sel(mark(x2), mark(x3))), tail(z0), x1, sel(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(sel(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), sel(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(sel(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), afterNth(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(sel(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), take(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(sel(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__sel(mark(x2), mark(x3))), cons(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(sel(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__sel(mark(x2), mark(x3))), s(z0), x1, sel(x2, x3)), A__SPLITAT(mark(s(z0)), mark(sel(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), pair(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(sel(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(0, a__sel(mark(x2), mark(x3))), 0, x1, sel(x2, x3)), A__SPLITAT(mark(0), mark(sel(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(nil, a__sel(mark(x2), mark(x3))), nil, x1, sel(x2, x3)), A__SPLITAT(mark(nil), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(mark(x2)), mark(mark(x3))))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), afterNth(mark(x2), mark(x3))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__natsFrom(mark(z0)))), x0, x1, afterNth(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__fst(mark(z0)))), x0, x1, afterNth(x2, fst(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__snd(mark(z0)))), x0, x1, afterNth(x2, snd(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, afterNth(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, afterNth(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(afterNth(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__head(mark(z0)))), x0, x1, afterNth(x2, head(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__tail(mark(z0)))), x0, x1, afterNth(x2, tail(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, afterNth(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, afterNth(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, afterNth(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), cons(mark(z0), z1))), x0, x1, afterNth(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), s(mark(z0)))), x0, x1, afterNth(x2, s(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, afterNth(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), 0)), x0, x1, afterNth(x2, 0)), A__SPLITAT(mark(x0), mark(afterNth(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), nil)), x0, x1, afterNth(x2, nil)), A__SPLITAT(mark(x0), mark(afterNth(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__natsFrom(mark(z0)), mark(x3))), x0, x1, afterNth(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__fst(mark(z0)), mark(x3))), x0, x1, afterNth(fst(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__snd(mark(z0)), mark(x3))), x0, x1, afterNth(snd(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, afterNth(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(afterNth(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__head(mark(z0)), mark(x3))), x0, x1, afterNth(head(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__tail(mark(z0)), mark(x3))), x0, x1, afterNth(tail(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(cons(mark(z0), z1), mark(x3))), x0, x1, afterNth(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(s(mark(z0)), mark(x3))), x0, x1, afterNth(s(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(0, mark(x3))), x0, x1, afterNth(0, x3)), A__SPLITAT(mark(x0), mark(afterNth(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(nil, mark(x3))), x0, x1, afterNth(nil, x3)), A__SPLITAT(mark(x0), mark(afterNth(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__afterNth(mark(x2), mark(x3))), natsFrom(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(afterNth(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__afterNth(mark(x2), mark(x3))), fst(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(afterNth(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__afterNth(mark(x2), mark(x3))), snd(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(afterNth(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), splitAt(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(afterNth(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__afterNth(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, afterNth(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(afterNth(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__afterNth(mark(x2), mark(x3))), head(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(head(z0)), mark(afterNth(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__afterNth(mark(x2), mark(x3))), tail(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(afterNth(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), sel(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(afterNth(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), afterNth(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(afterNth(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), take(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(afterNth(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__afterNth(mark(x2), mark(x3))), cons(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(afterNth(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__afterNth(mark(x2), mark(x3))), s(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(s(z0)), mark(afterNth(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), pair(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(afterNth(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(afterNth(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(0, a__afterNth(mark(x2), mark(x3))), 0, x1, afterNth(x2, x3)), A__SPLITAT(mark(0), mark(afterNth(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(nil, a__afterNth(mark(x2), mark(x3))), nil, x1, afterNth(x2, x3)), A__SPLITAT(mark(nil), mark(afterNth(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(mark(x2)), mark(mark(x3))))), x0, x1, take(x2, x3)), A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), take(mark(x2), mark(x3))), x0, x1, take(x2, x3)), A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__natsFrom(mark(z0)))), x0, x1, take(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(take(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__fst(mark(z0)))), x0, x1, take(x2, fst(z0))), A__SPLITAT(mark(x0), mark(take(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__snd(mark(z0)))), x0, x1, take(x2, snd(z0))), A__SPLITAT(mark(x0), mark(take(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, take(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, take(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(take(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__head(mark(z0)))), x0, x1, take(x2, head(z0))), A__SPLITAT(mark(x0), mark(take(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__tail(mark(z0)))), x0, x1, take(x2, tail(z0))), A__SPLITAT(mark(x0), mark(take(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, take(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, take(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, take(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), cons(mark(z0), z1))), x0, x1, take(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), s(mark(z0)))), x0, x1, take(x2, s(z0))), A__SPLITAT(mark(x0), mark(take(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, take(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), 0)), x0, x1, take(x2, 0)), A__SPLITAT(mark(x0), mark(take(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), nil)), x0, x1, take(x2, nil)), A__SPLITAT(mark(x0), mark(take(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__natsFrom(mark(z0)), mark(x3))), x0, x1, take(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(take(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__fst(mark(z0)), mark(x3))), x0, x1, take(fst(z0), x3)), A__SPLITAT(mark(x0), mark(take(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__snd(mark(z0)), mark(x3))), x0, x1, take(snd(z0), x3)), A__SPLITAT(mark(x0), mark(take(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, take(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, take(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(take(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__head(mark(z0)), mark(x3))), x0, x1, take(head(z0), x3)), A__SPLITAT(mark(x0), mark(take(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__tail(mark(z0)), mark(x3))), x0, x1, take(tail(z0), x3)), A__SPLITAT(mark(x0), mark(take(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, take(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, take(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, take(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(cons(mark(z0), z1), mark(x3))), x0, x1, take(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(s(mark(z0)), mark(x3))), x0, x1, take(s(z0), x3)), A__SPLITAT(mark(x0), mark(take(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, take(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(0, mark(x3))), x0, x1, take(0, x3)), A__SPLITAT(mark(x0), mark(take(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(nil, mark(x3))), x0, x1, take(nil, x3)), A__SPLITAT(mark(x0), mark(take(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__take(mark(x2), mark(x3))), natsFrom(z0), x1, take(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(take(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__take(mark(x2), mark(x3))), fst(z0), x1, take(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(take(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__take(mark(x2), mark(x3))), snd(z0), x1, take(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(take(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), splitAt(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(take(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__take(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, take(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(take(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__take(mark(x2), mark(x3))), head(z0), x1, take(x2, x3)), A__SPLITAT(mark(head(z0)), mark(take(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__take(mark(x2), mark(x3))), tail(z0), x1, take(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(take(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), sel(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(take(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), afterNth(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(take(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), take(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(take(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__take(mark(x2), mark(x3))), cons(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(take(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__take(mark(x2), mark(x3))), s(z0), x1, take(x2, x3)), A__SPLITAT(mark(s(z0)), mark(take(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), pair(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(take(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(take(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(0, a__take(mark(x2), mark(x3))), 0, x1, take(x2, x3)), A__SPLITAT(mark(0), mark(take(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(nil, a__take(mark(x2), mark(x3))), nil, x1, take(x2, x3)), A__SPLITAT(mark(nil), mark(take(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, cons(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__natsFrom(mark(z0)), x3)), x0, x1, cons(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(cons(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__fst(mark(z0)), x3)), x0, x1, cons(fst(z0), x3)), A__SPLITAT(mark(x0), mark(cons(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__snd(mark(z0)), x3)), x0, x1, cons(snd(z0), x3)), A__SPLITAT(mark(x0), mark(cons(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__splitAt(mark(z0), mark(z1)), x3)), x0, x1, cons(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__u(mark(z0), z1, z2, z3), x3)), x0, x1, cons(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(cons(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__head(mark(z0)), x3)), x0, x1, cons(head(z0), x3)), A__SPLITAT(mark(x0), mark(cons(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__tail(mark(z0)), x3)), x0, x1, cons(tail(z0), x3)), A__SPLITAT(mark(x0), mark(cons(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__sel(mark(z0), mark(z1)), x3)), x0, x1, cons(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__afterNth(mark(z0), mark(z1)), x3)), x0, x1, cons(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__take(mark(z0), mark(z1)), x3)), x0, x1, cons(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(cons(mark(z0), z1), x3)), x0, x1, cons(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(s(mark(z0)), x3)), x0, x1, cons(s(z0), x3)), A__SPLITAT(mark(x0), mark(cons(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(pair(mark(z0), mark(z1)), x3)), x0, x1, cons(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(0, x3))) -> c7(A__U(a__splitAt(mark(x0), cons(0, x3)), x0, x1, cons(0, x3)), A__SPLITAT(mark(x0), mark(cons(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), cons(nil, x3)), x0, x1, cons(nil, x3)), A__SPLITAT(mark(x0), mark(cons(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), cons(mark(x2), x3)), natsFrom(z0), x1, cons(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(cons(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), cons(mark(x2), x3)), fst(z0), x1, cons(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(cons(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), cons(mark(x2), x3)), snd(z0), x1, cons(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(cons(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), cons(mark(x2), x3)), splitAt(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(cons(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), cons(mark(x2), x3)), u(z0, z1, z2, z3), x1, cons(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(cons(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), cons(mark(x2), x3)), head(z0), x1, cons(x2, x3)), A__SPLITAT(mark(head(z0)), mark(cons(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), cons(mark(x2), x3)), tail(z0), x1, cons(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(cons(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), cons(mark(x2), x3)), sel(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(cons(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), cons(mark(x2), x3)), afterNth(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(cons(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), cons(mark(x2), x3)), take(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(cons(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), cons(mark(x2), x3)), cons(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(cons(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), cons(mark(x2), x3)), s(z0), x1, cons(x2, x3)), A__SPLITAT(mark(s(z0)), mark(cons(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), cons(mark(x2), x3)), pair(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(cons(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(cons(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, cons(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(cons(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(0, cons(mark(x2), x3)), 0, x1, cons(x2, x3)), A__SPLITAT(mark(0), mark(cons(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(nil, cons(mark(x2), x3)), nil, x1, cons(x2, x3)), A__SPLITAT(mark(nil), mark(cons(x2, x3))))
S tuples:
   A__NATSFROM(z0) -> c(MARK(z0))
   A__FST(pair(z0, z1)) -> c2(MARK(z0))
   A__SND(pair(z0, z1)) -> c4(MARK(z1))
   A__SPLITAT(0, z0) -> c6(MARK(z0))
   A__U(pair(z0, z1), z2, z3, z4) -> c10(MARK(z3))
   A__U(pair(z0, z1), z2, z3, z4) -> c11(MARK(z1))
   A__HEAD(cons(z0, z1)) -> c13(MARK(z0))
   A__TAIL(cons(z0, z1)) -> c15(MARK(z1))
   MARK(natsFrom(z0)) -> c26(A__NATSFROM(mark(z0)), MARK(z0))
   MARK(sel(z0, z1)) -> c34(A__SEL(mark(z0), mark(z1)), MARK(z0))
   MARK(sel(z0, z1)) -> c35(A__SEL(mark(z0), mark(z1)), MARK(z1))
   MARK(afterNth(z0, z1)) -> c36(A__AFTERNTH(mark(z0), mark(z1)), MARK(z0))
   MARK(afterNth(z0, z1)) -> c37(A__AFTERNTH(mark(z0), mark(z1)), MARK(z1))
   MARK(take(z0, z1)) -> c38(A__TAKE(mark(z0), mark(z1)), MARK(z0))
   MARK(take(z0, z1)) -> c39(A__TAKE(mark(z0), mark(z1)), MARK(z1))
   MARK(cons(z0, z1)) -> c40(MARK(z0))
   MARK(s(z0)) -> c41(MARK(z0))
   MARK(pair(z0, z1)) -> c42(MARK(z0))
   MARK(pair(z0, z1)) -> c43(MARK(z1))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c7(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c7(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c7(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c7(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c7(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c7(A__SPLITAT(mark(x0), mark(x2)), MARK(x0))
   A__SPLITAT(s(0), cons(x1, x2)) -> c7(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c7(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(z0))) -> c8(A__U(a__splitAt(mark(x0), a__natsFrom(mark(z0))), x0, x1, natsFrom(z0)), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SPLITAT(s(x0), cons(x1, fst(z0))) -> c8(A__U(a__splitAt(mark(x0), a__fst(mark(z0))), x0, x1, fst(z0)), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SPLITAT(s(x0), cons(x1, snd(z0))) -> c8(A__U(a__splitAt(mark(x0), a__snd(mark(z0))), x0, x1, snd(z0)), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SPLITAT(s(x0), cons(x1, splitAt(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1))), x0, x1, splitAt(z0, z1)), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(z0, z1, z2, z3))) -> c8(A__U(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3)), x0, x1, u(z0, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(x0), cons(x1, head(z0))) -> c8(A__U(a__splitAt(mark(x0), a__head(mark(z0))), x0, x1, head(z0)), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SPLITAT(s(x0), cons(x1, tail(z0))) -> c8(A__U(a__splitAt(mark(x0), a__tail(mark(z0))), x0, x1, tail(z0)), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SPLITAT(s(x0), cons(x1, sel(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1))), x0, x1, sel(z0, z1)), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1))), x0, x1, afterNth(z0, z1)), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), a__take(mark(z0), mark(z1))), x0, x1, take(z0, z1)), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), cons(mark(z0), z1)), x0, x1, cons(z0, z1)), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, s(z0))) -> c8(A__U(a__splitAt(mark(x0), s(mark(z0))), x0, x1, s(z0)), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SPLITAT(s(x0), cons(x1, pair(z0, z1))) -> c8(A__U(a__splitAt(mark(x0), pair(mark(z0), mark(z1))), x0, x1, pair(z0, z1)), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__natsFrom(mark(z0)), mark(x2)), natsFrom(z0), x1, x2), A__SPLITAT(mark(natsFrom(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(fst(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__fst(mark(z0)), mark(x2)), fst(z0), x1, x2), A__SPLITAT(mark(fst(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(snd(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__snd(mark(z0)), mark(x2)), snd(z0), x1, x2), A__SPLITAT(mark(snd(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x2)), splitAt(z0, z1), x1, x2), A__SPLITAT(mark(splitAt(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x2)), u(z0, z1, z2, z3), x1, x2), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x2)), MARK(x2))
   A__SPLITAT(s(head(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__head(mark(z0)), mark(x2)), head(z0), x1, x2), A__SPLITAT(mark(head(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(tail(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__tail(mark(z0)), mark(x2)), tail(z0), x1, x2), A__SPLITAT(mark(tail(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x2)), sel(z0, z1), x1, x2), A__SPLITAT(mark(sel(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x2)), afterNth(z0, z1), x1, x2), A__SPLITAT(mark(afterNth(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(take(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(a__take(mark(z0), mark(z1)), mark(x2)), take(z0, z1), x1, x2), A__SPLITAT(mark(take(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(cons(mark(z0), z1), mark(x2)), cons(z0, z1), x1, x2), A__SPLITAT(mark(cons(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(s(z0)), cons(x1, x2)) -> c8(A__U(a__splitAt(s(mark(z0)), mark(x2)), s(z0), x1, x2), A__SPLITAT(mark(s(z0)), mark(x2)), MARK(x2))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, x2)) -> c8(A__U(a__splitAt(pair(mark(z0), mark(z1)), mark(x2)), pair(z0, z1), x1, x2), A__SPLITAT(mark(pair(z0, z1)), mark(x2)), MARK(x2))
   A__SPLITAT(s(0), cons(x1, x2)) -> c8(A__U(a__splitAt(0, mark(x2)), 0, x1, x2), A__SPLITAT(mark(0), mark(x2)), MARK(x2))
   A__SPLITAT(s(nil), cons(x1, x2)) -> c8(A__U(a__splitAt(nil, mark(x2)), nil, x1, x2), A__SPLITAT(mark(nil), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, x2)) -> c8(A__SPLITAT(mark(x0), mark(x2)), MARK(x2))
   A__SPLITAT(s(x0), cons(x1, 0)) -> c8(A__U(a__splitAt(mark(x0), 0), x0, x1, 0), A__SPLITAT(mark(x0), mark(0)))
   A__SPLITAT(s(x0), cons(x1, nil)) -> c8(A__U(a__splitAt(mark(x0), nil), x0, x1, nil), A__SPLITAT(mark(x0), mark(nil)))
   A__SEL(x0, x1) -> c17(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(x0, natsFrom(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__SEL(x0, fst(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(x0))
   A__SEL(x0, snd(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(x0))
   A__SEL(x0, splitAt(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c17(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__SEL(x0, head(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(x0))
   A__SEL(x0, tail(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(x0))
   A__SEL(x0, sel(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__SEL(x0, afterNth(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__SEL(x0, take(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__SEL(x0, cons(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__SEL(x0, s(z0)) -> c17(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(x0))
   A__SEL(x0, pair(z0, z1)) -> c17(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__SEL(x0, 0) -> c17(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)), MARK(x0))
   A__SEL(x0, nil) -> c17(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)), MARK(x0))
   A__SEL(natsFrom(z0), x1) -> c17(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__SEL(fst(z0), x1) -> c17(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__SEL(snd(z0), x1) -> c17(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__SEL(splitAt(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__SEL(u(z0, z1, z2, z3), x1) -> c17(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__SEL(head(z0), x1) -> c17(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__SEL(tail(z0), x1) -> c17(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__SEL(sel(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__SEL(afterNth(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__SEL(take(z0, z1), x1) -> c17(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__SEL(cons(z0, z1), x1) -> c17(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__SEL(s(z0), x1) -> c17(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__SEL(pair(z0, z1), x1) -> c17(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__SEL(x0, x1) -> c17(A__AFTERNTH(mark(x0), mark(x1)), MARK(x0))
   A__SEL(0, x1) -> c17(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)))
   A__SEL(nil, x1) -> c17(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)))
   A__SEL(x0, x1) -> c18(A__HEAD(a__snd(a__splitAt(mark(mark(x0)), mark(mark(x1))))), A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, natsFrom(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__natsFrom(mark(z0)))), A__AFTERNTH(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__SEL(x0, fst(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__fst(mark(z0)))), A__AFTERNTH(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__SEL(x0, snd(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__snd(mark(z0)))), A__AFTERNTH(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__SEL(x0, splitAt(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__SEL(x0, u(z0, z1, z2, z3)) -> c18(A__HEAD(a__afterNth(mark(x0), a__u(mark(z0), z1, z2, z3))), A__AFTERNTH(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__SEL(x0, head(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__head(mark(z0)))), A__AFTERNTH(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__SEL(x0, tail(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), a__tail(mark(z0)))), A__AFTERNTH(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__SEL(x0, sel(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__sel(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__SEL(x0, afterNth(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__SEL(x0, take(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), a__take(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__SEL(x0, cons(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), cons(mark(z0), z1))), A__AFTERNTH(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__SEL(x0, s(z0)) -> c18(A__HEAD(a__afterNth(mark(x0), s(mark(z0)))), A__AFTERNTH(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__SEL(x0, pair(z0, z1)) -> c18(A__HEAD(a__afterNth(mark(x0), pair(mark(z0), mark(z1)))), A__AFTERNTH(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__SEL(natsFrom(z0), x1) -> c18(A__HEAD(a__afterNth(a__natsFrom(mark(z0)), mark(x1))), A__AFTERNTH(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__SEL(fst(z0), x1) -> c18(A__HEAD(a__afterNth(a__fst(mark(z0)), mark(x1))), A__AFTERNTH(mark(fst(z0)), mark(x1)), MARK(x1))
   A__SEL(snd(z0), x1) -> c18(A__HEAD(a__afterNth(a__snd(mark(z0)), mark(x1))), A__AFTERNTH(mark(snd(z0)), mark(x1)), MARK(x1))
   A__SEL(splitAt(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(u(z0, z1, z2, z3), x1) -> c18(A__HEAD(a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x1))), A__AFTERNTH(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__SEL(head(z0), x1) -> c18(A__HEAD(a__afterNth(a__head(mark(z0)), mark(x1))), A__AFTERNTH(mark(head(z0)), mark(x1)), MARK(x1))
   A__SEL(tail(z0), x1) -> c18(A__HEAD(a__afterNth(a__tail(mark(z0)), mark(x1))), A__AFTERNTH(mark(tail(z0)), mark(x1)), MARK(x1))
   A__SEL(sel(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__sel(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(afterNth(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(take(z0, z1), x1) -> c18(A__HEAD(a__afterNth(a__take(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(cons(z0, z1), x1) -> c18(A__HEAD(a__afterNth(cons(mark(z0), z1), mark(x1))), A__AFTERNTH(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(s(z0), x1) -> c18(A__HEAD(a__afterNth(s(mark(z0)), mark(x1))), A__AFTERNTH(mark(s(z0)), mark(x1)), MARK(x1))
   A__SEL(pair(z0, z1), x1) -> c18(A__HEAD(a__afterNth(pair(mark(z0), mark(z1)), mark(x1))), A__AFTERNTH(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__SEL(0, x1) -> c18(A__HEAD(a__afterNth(0, mark(x1))), A__AFTERNTH(mark(0), mark(x1)), MARK(x1))
   A__SEL(nil, x1) -> c18(A__HEAD(a__afterNth(nil, mark(x1))), A__AFTERNTH(mark(nil), mark(x1)), MARK(x1))
   A__SEL(x0, x1) -> c18(A__AFTERNTH(mark(x0), mark(x1)), MARK(x1))
   A__SEL(x0, 0) -> c18(A__HEAD(a__afterNth(mark(x0), 0)), A__AFTERNTH(mark(x0), mark(0)))
   A__SEL(x0, nil) -> c18(A__HEAD(a__afterNth(mark(x0), nil)), A__AFTERNTH(mark(x0), mark(nil)))
   A__TAKE(x0, natsFrom(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__TAKE(x0, fst(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__TAKE(x0, snd(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__TAKE(x0, splitAt(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c20(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__TAKE(x0, head(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__TAKE(x0, tail(z0)) -> c20(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__TAKE(x0, sel(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__TAKE(x0, afterNth(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__TAKE(x0, take(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__TAKE(x0, cons(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__TAKE(x0, s(z0)) -> c20(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__TAKE(x0, pair(z0, z1)) -> c20(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__TAKE(x0, 0) -> c20(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__TAKE(x0, nil) -> c20(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__TAKE(natsFrom(z0), x1) -> c20(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__TAKE(fst(z0), x1) -> c20(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__TAKE(snd(z0), x1) -> c20(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__TAKE(splitAt(z0, z1), x1) -> c20(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c20(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__TAKE(head(z0), x1) -> c20(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__TAKE(tail(z0), x1) -> c20(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__TAKE(sel(z0, z1), x1) -> c20(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__TAKE(afterNth(z0, z1), x1) -> c20(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__TAKE(take(z0, z1), x1) -> c20(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__TAKE(cons(z0, z1), x1) -> c20(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__TAKE(s(z0), x1) -> c20(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__TAKE(pair(z0, z1), x1) -> c20(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__TAKE(x0, x1) -> c20(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__TAKE(0, x1) -> c20(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__TAKE(nil, x1) -> c20(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__TAKE(x0, natsFrom(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__TAKE(x0, fst(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__TAKE(x0, snd(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__TAKE(x0, splitAt(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__TAKE(x0, u(z0, z1, z2, z3)) -> c21(A__FST(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__TAKE(x0, head(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__TAKE(x0, tail(z0)) -> c21(A__FST(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__TAKE(x0, sel(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__TAKE(x0, afterNth(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__TAKE(x0, take(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__TAKE(x0, cons(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__TAKE(x0, s(z0)) -> c21(A__FST(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__TAKE(x0, pair(z0, z1)) -> c21(A__FST(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__TAKE(natsFrom(z0), x1) -> c21(A__FST(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__TAKE(fst(z0), x1) -> c21(A__FST(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__TAKE(snd(z0), x1) -> c21(A__FST(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__TAKE(splitAt(z0, z1), x1) -> c21(A__FST(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(u(z0, z1, z2, z3), x1) -> c21(A__FST(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__TAKE(head(z0), x1) -> c21(A__FST(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__TAKE(tail(z0), x1) -> c21(A__FST(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__TAKE(sel(z0, z1), x1) -> c21(A__FST(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(afterNth(z0, z1), x1) -> c21(A__FST(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(take(z0, z1), x1) -> c21(A__FST(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(cons(z0, z1), x1) -> c21(A__FST(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(s(z0), x1) -> c21(A__FST(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__TAKE(pair(z0, z1), x1) -> c21(A__FST(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__TAKE(0, x1) -> c21(A__FST(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__TAKE(nil, x1) -> c21(A__FST(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__TAKE(x0, x1) -> c21(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__TAKE(x0, 0) -> c21(A__FST(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__TAKE(x0, nil) -> c21(A__FST(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(x0))
   A__AFTERNTH(x0, fst(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(x0))
   A__AFTERNTH(x0, snd(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(x0))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c23(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(x0))
   A__AFTERNTH(x0, head(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(x0))
   A__AFTERNTH(x0, tail(z0)) -> c23(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(x0))
   A__AFTERNTH(x0, sel(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, take(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, cons(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, s(z0)) -> c23(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(x0))
   A__AFTERNTH(x0, pair(z0, z1)) -> c23(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(x0))
   A__AFTERNTH(x0, 0) -> c23(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)), MARK(x0))
   A__AFTERNTH(x0, nil) -> c23(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)), MARK(x0))
   A__AFTERNTH(natsFrom(z0), x1) -> c23(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(natsFrom(z0)))
   A__AFTERNTH(fst(z0), x1) -> c23(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(fst(z0)))
   A__AFTERNTH(snd(z0), x1) -> c23(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(snd(z0)))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c23(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(splitAt(z0, z1)))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c23(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(head(z0), x1) -> c23(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(head(z0)))
   A__AFTERNTH(tail(z0), x1) -> c23(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(tail(z0)))
   A__AFTERNTH(sel(z0, z1), x1) -> c23(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(sel(z0, z1)))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c23(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(afterNth(z0, z1)))
   A__AFTERNTH(take(z0, z1), x1) -> c23(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(take(z0, z1)))
   A__AFTERNTH(cons(z0, z1), x1) -> c23(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(cons(z0, z1)))
   A__AFTERNTH(s(z0), x1) -> c23(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(s(z0)))
   A__AFTERNTH(pair(z0, z1), x1) -> c23(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(pair(z0, z1)))
   A__AFTERNTH(x0, x1) -> c23(A__SPLITAT(mark(x0), mark(x1)), MARK(x0))
   A__AFTERNTH(0, x1) -> c23(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)))
   A__AFTERNTH(nil, x1) -> c23(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)))
   A__AFTERNTH(x0, natsFrom(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__natsFrom(mark(z0)))), A__SPLITAT(mark(x0), mark(natsFrom(z0))), MARK(natsFrom(z0)))
   A__AFTERNTH(x0, fst(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__fst(mark(z0)))), A__SPLITAT(mark(x0), mark(fst(z0))), MARK(fst(z0)))
   A__AFTERNTH(x0, snd(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__snd(mark(z0)))), A__SPLITAT(mark(x0), mark(snd(z0))), MARK(snd(z0)))
   A__AFTERNTH(x0, splitAt(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__splitAt(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(splitAt(z0, z1))), MARK(splitAt(z0, z1)))
   A__AFTERNTH(x0, u(z0, z1, z2, z3)) -> c24(A__SND(a__splitAt(mark(x0), a__u(mark(z0), z1, z2, z3))), A__SPLITAT(mark(x0), mark(u(z0, z1, z2, z3))), MARK(u(z0, z1, z2, z3)))
   A__AFTERNTH(x0, head(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__head(mark(z0)))), A__SPLITAT(mark(x0), mark(head(z0))), MARK(head(z0)))
   A__AFTERNTH(x0, tail(z0)) -> c24(A__SND(a__splitAt(mark(x0), a__tail(mark(z0)))), A__SPLITAT(mark(x0), mark(tail(z0))), MARK(tail(z0)))
   A__AFTERNTH(x0, sel(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__sel(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(sel(z0, z1))), MARK(sel(z0, z1)))
   A__AFTERNTH(x0, afterNth(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__afterNth(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(afterNth(z0, z1))), MARK(afterNth(z0, z1)))
   A__AFTERNTH(x0, take(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), a__take(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(take(z0, z1))), MARK(take(z0, z1)))
   A__AFTERNTH(x0, cons(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), cons(mark(z0), z1))), A__SPLITAT(mark(x0), mark(cons(z0, z1))), MARK(cons(z0, z1)))
   A__AFTERNTH(x0, s(z0)) -> c24(A__SND(a__splitAt(mark(x0), s(mark(z0)))), A__SPLITAT(mark(x0), mark(s(z0))), MARK(s(z0)))
   A__AFTERNTH(x0, pair(z0, z1)) -> c24(A__SND(a__splitAt(mark(x0), pair(mark(z0), mark(z1)))), A__SPLITAT(mark(x0), mark(pair(z0, z1))), MARK(pair(z0, z1)))
   A__AFTERNTH(natsFrom(z0), x1) -> c24(A__SND(a__splitAt(a__natsFrom(mark(z0)), mark(x1))), A__SPLITAT(mark(natsFrom(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(fst(z0), x1) -> c24(A__SND(a__splitAt(a__fst(mark(z0)), mark(x1))), A__SPLITAT(mark(fst(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(snd(z0), x1) -> c24(A__SND(a__splitAt(a__snd(mark(z0)), mark(x1))), A__SPLITAT(mark(snd(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(splitAt(z0, z1), x1) -> c24(A__SND(a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(splitAt(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(u(z0, z1, z2, z3), x1) -> c24(A__SND(a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x1))), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(x1)), MARK(x1))
   A__AFTERNTH(head(z0), x1) -> c24(A__SND(a__splitAt(a__head(mark(z0)), mark(x1))), A__SPLITAT(mark(head(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(tail(z0), x1) -> c24(A__SND(a__splitAt(a__tail(mark(z0)), mark(x1))), A__SPLITAT(mark(tail(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(sel(z0, z1), x1) -> c24(A__SND(a__splitAt(a__sel(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(sel(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(afterNth(z0, z1), x1) -> c24(A__SND(a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(afterNth(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(take(z0, z1), x1) -> c24(A__SND(a__splitAt(a__take(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(take(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(cons(z0, z1), x1) -> c24(A__SND(a__splitAt(cons(mark(z0), z1), mark(x1))), A__SPLITAT(mark(cons(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(s(z0), x1) -> c24(A__SND(a__splitAt(s(mark(z0)), mark(x1))), A__SPLITAT(mark(s(z0)), mark(x1)), MARK(x1))
   A__AFTERNTH(pair(z0, z1), x1) -> c24(A__SND(a__splitAt(pair(mark(z0), mark(z1)), mark(x1))), A__SPLITAT(mark(pair(z0, z1)), mark(x1)), MARK(x1))
   A__AFTERNTH(0, x1) -> c24(A__SND(a__splitAt(0, mark(x1))), A__SPLITAT(mark(0), mark(x1)), MARK(x1))
   A__AFTERNTH(nil, x1) -> c24(A__SND(a__splitAt(nil, mark(x1))), A__SPLITAT(mark(nil), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, x1) -> c24(A__SPLITAT(mark(x0), mark(x1)), MARK(x1))
   A__AFTERNTH(x0, 0) -> c24(A__SND(a__splitAt(mark(x0), 0)), A__SPLITAT(mark(x0), mark(0)))
   A__AFTERNTH(x0, nil) -> c24(A__SND(a__splitAt(mark(x0), nil)), A__SPLITAT(mark(x0), mark(nil)))
   MARK(fst(natsFrom(z0))) -> c27(A__FST(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(fst(fst(z0))) -> c27(A__FST(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(fst(snd(z0))) -> c27(A__FST(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(fst(splitAt(z0, z1))) -> c27(A__FST(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(fst(u(z0, z1, z2, z3))) -> c27(A__FST(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(fst(head(z0))) -> c27(A__FST(a__head(mark(z0))), MARK(head(z0)))
   MARK(fst(tail(z0))) -> c27(A__FST(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(fst(sel(z0, z1))) -> c27(A__FST(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(fst(afterNth(z0, z1))) -> c27(A__FST(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(fst(take(z0, z1))) -> c27(A__FST(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(fst(pair(z0, z1))) -> c27(A__FST(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(fst(cons(z0, z1))) -> c27(MARK(cons(z0, z1)))
   MARK(fst(s(z0))) -> c27(MARK(s(z0)))
   MARK(snd(natsFrom(z0))) -> c28(A__SND(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(snd(fst(z0))) -> c28(A__SND(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(snd(snd(z0))) -> c28(A__SND(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(snd(splitAt(z0, z1))) -> c28(A__SND(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(snd(u(z0, z1, z2, z3))) -> c28(A__SND(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(snd(head(z0))) -> c28(A__SND(a__head(mark(z0))), MARK(head(z0)))
   MARK(snd(tail(z0))) -> c28(A__SND(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(snd(sel(z0, z1))) -> c28(A__SND(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(snd(afterNth(z0, z1))) -> c28(A__SND(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(snd(take(z0, z1))) -> c28(A__SND(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(snd(pair(z0, z1))) -> c28(A__SND(pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(snd(cons(z0, z1))) -> c28(MARK(cons(z0, z1)))
   MARK(snd(s(z0))) -> c28(MARK(s(z0)))
   MARK(splitAt(x0, natsFrom(z0))) -> c29(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(x0))
   MARK(splitAt(x0, fst(z0))) -> c29(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(x0))
   MARK(splitAt(x0, snd(z0))) -> c29(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(x0))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c29(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(x0))
   MARK(splitAt(x0, head(z0))) -> c29(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(x0))
   MARK(splitAt(x0, tail(z0))) -> c29(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(x0))
   MARK(splitAt(x0, sel(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, take(z0, z1))) -> c29(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, cons(z0, z1))) -> c29(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(x0))
   MARK(splitAt(x0, s(z0))) -> c29(A__SPLITAT(mark(x0), s(mark(z0))), MARK(x0))
   MARK(splitAt(x0, pair(z0, z1))) -> c29(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(x0))
   MARK(splitAt(x0, 0)) -> c29(A__SPLITAT(mark(x0), 0), MARK(x0))
   MARK(splitAt(x0, nil)) -> c29(A__SPLITAT(mark(x0), nil), MARK(x0))
   MARK(splitAt(natsFrom(z0), x1)) -> c29(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(natsFrom(z0)))
   MARK(splitAt(fst(z0), x1)) -> c29(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(fst(z0)))
   MARK(splitAt(snd(z0), x1)) -> c29(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(snd(z0)))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c29(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(splitAt(z0, z1)))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c29(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(head(z0), x1)) -> c29(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(head(z0)))
   MARK(splitAt(tail(z0), x1)) -> c29(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(tail(z0)))
   MARK(splitAt(sel(z0, z1), x1)) -> c29(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(sel(z0, z1)))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c29(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(afterNth(z0, z1)))
   MARK(splitAt(take(z0, z1), x1)) -> c29(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(take(z0, z1)))
   MARK(splitAt(s(z0), x1)) -> c29(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(s(z0)))
   MARK(splitAt(cons(z0, z1), x1)) -> c29(MARK(cons(z0, z1)))
   MARK(splitAt(pair(z0, z1), x1)) -> c29(MARK(pair(z0, z1)))
   MARK(splitAt(0, x1)) -> c29(A__SPLITAT(0, mark(x1)))
   MARK(splitAt(x0, natsFrom(z0))) -> c30(A__SPLITAT(mark(x0), a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(splitAt(x0, fst(z0))) -> c30(A__SPLITAT(mark(x0), a__fst(mark(z0))), MARK(fst(z0)))
   MARK(splitAt(x0, snd(z0))) -> c30(A__SPLITAT(mark(x0), a__snd(mark(z0))), MARK(snd(z0)))
   MARK(splitAt(x0, splitAt(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(splitAt(x0, u(z0, z1, z2, z3))) -> c30(A__SPLITAT(mark(x0), a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(splitAt(x0, head(z0))) -> c30(A__SPLITAT(mark(x0), a__head(mark(z0))), MARK(head(z0)))
   MARK(splitAt(x0, tail(z0))) -> c30(A__SPLITAT(mark(x0), a__tail(mark(z0))), MARK(tail(z0)))
   MARK(splitAt(x0, sel(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(splitAt(x0, afterNth(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(splitAt(x0, take(z0, z1))) -> c30(A__SPLITAT(mark(x0), a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(splitAt(x0, cons(z0, z1))) -> c30(A__SPLITAT(mark(x0), cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(splitAt(x0, s(z0))) -> c30(A__SPLITAT(mark(x0), s(mark(z0))), MARK(s(z0)))
   MARK(splitAt(x0, pair(z0, z1))) -> c30(A__SPLITAT(mark(x0), pair(mark(z0), mark(z1))), MARK(pair(z0, z1)))
   MARK(splitAt(natsFrom(z0), x1)) -> c30(A__SPLITAT(a__natsFrom(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(fst(z0), x1)) -> c30(A__SPLITAT(a__fst(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(snd(z0), x1)) -> c30(A__SPLITAT(a__snd(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(splitAt(z0, z1), x1)) -> c30(A__SPLITAT(a__splitAt(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(u(z0, z1, z2, z3), x1)) -> c30(A__SPLITAT(a__u(mark(z0), z1, z2, z3), mark(x1)), MARK(x1))
   MARK(splitAt(head(z0), x1)) -> c30(A__SPLITAT(a__head(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(tail(z0), x1)) -> c30(A__SPLITAT(a__tail(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(sel(z0, z1), x1)) -> c30(A__SPLITAT(a__sel(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(afterNth(z0, z1), x1)) -> c30(A__SPLITAT(a__afterNth(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(take(z0, z1), x1)) -> c30(A__SPLITAT(a__take(mark(z0), mark(z1)), mark(x1)), MARK(x1))
   MARK(splitAt(s(z0), x1)) -> c30(A__SPLITAT(s(mark(z0)), mark(x1)), MARK(x1))
   MARK(splitAt(0, x1)) -> c30(A__SPLITAT(0, mark(x1)), MARK(x1))
   MARK(splitAt(x0, 0)) -> c30(A__SPLITAT(mark(x0), 0))
   MARK(splitAt(x0, nil)) -> c30(A__SPLITAT(mark(x0), nil))
   MARK(splitAt(cons(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(pair(z0, z1), x1)) -> c30(MARK(x1))
   MARK(splitAt(nil, x1)) -> c30(MARK(x1))
   MARK(u(natsFrom(z0), x1, x2, x3)) -> c31(A__U(a__natsFrom(mark(z0)), x1, x2, x3), MARK(natsFrom(z0)))
   MARK(u(fst(z0), x1, x2, x3)) -> c31(A__U(a__fst(mark(z0)), x1, x2, x3), MARK(fst(z0)))
   MARK(u(snd(z0), x1, x2, x3)) -> c31(A__U(a__snd(mark(z0)), x1, x2, x3), MARK(snd(z0)))
   MARK(u(splitAt(z0, z1), x1, x2, x3)) -> c31(A__U(a__splitAt(mark(z0), mark(z1)), x1, x2, x3), MARK(splitAt(z0, z1)))
   MARK(u(u(z0, z1, z2, z3), x1, x2, x3)) -> c31(A__U(a__u(mark(z0), z1, z2, z3), x1, x2, x3), MARK(u(z0, z1, z2, z3)))
   MARK(u(head(z0), x1, x2, x3)) -> c31(A__U(a__head(mark(z0)), x1, x2, x3), MARK(head(z0)))
   MARK(u(tail(z0), x1, x2, x3)) -> c31(A__U(a__tail(mark(z0)), x1, x2, x3), MARK(tail(z0)))
   MARK(u(sel(z0, z1), x1, x2, x3)) -> c31(A__U(a__sel(mark(z0), mark(z1)), x1, x2, x3), MARK(sel(z0, z1)))
   MARK(u(afterNth(z0, z1), x1, x2, x3)) -> c31(A__U(a__afterNth(mark(z0), mark(z1)), x1, x2, x3), MARK(afterNth(z0, z1)))
   MARK(u(take(z0, z1), x1, x2, x3)) -> c31(A__U(a__take(mark(z0), mark(z1)), x1, x2, x3), MARK(take(z0, z1)))
   MARK(u(pair(z0, z1), x1, x2, x3)) -> c31(A__U(pair(mark(z0), mark(z1)), x1, x2, x3), MARK(pair(z0, z1)))
   MARK(u(cons(z0, z1), x1, x2, x3)) -> c31(MARK(cons(z0, z1)))
   MARK(u(s(z0), x1, x2, x3)) -> c31(MARK(s(z0)))
   MARK(head(natsFrom(z0))) -> c32(A__HEAD(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(head(fst(z0))) -> c32(A__HEAD(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(head(snd(z0))) -> c32(A__HEAD(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(head(splitAt(z0, z1))) -> c32(A__HEAD(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(head(u(z0, z1, z2, z3))) -> c32(A__HEAD(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(head(head(z0))) -> c32(A__HEAD(a__head(mark(z0))), MARK(head(z0)))
   MARK(head(tail(z0))) -> c32(A__HEAD(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(head(sel(z0, z1))) -> c32(A__HEAD(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(head(afterNth(z0, z1))) -> c32(A__HEAD(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(head(take(z0, z1))) -> c32(A__HEAD(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(head(cons(z0, z1))) -> c32(A__HEAD(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(head(s(z0))) -> c32(MARK(s(z0)))
   MARK(head(pair(z0, z1))) -> c32(MARK(pair(z0, z1)))
   MARK(tail(natsFrom(z0))) -> c33(A__TAIL(a__natsFrom(mark(z0))), MARK(natsFrom(z0)))
   MARK(tail(fst(z0))) -> c33(A__TAIL(a__fst(mark(z0))), MARK(fst(z0)))
   MARK(tail(snd(z0))) -> c33(A__TAIL(a__snd(mark(z0))), MARK(snd(z0)))
   MARK(tail(splitAt(z0, z1))) -> c33(A__TAIL(a__splitAt(mark(z0), mark(z1))), MARK(splitAt(z0, z1)))
   MARK(tail(u(z0, z1, z2, z3))) -> c33(A__TAIL(a__u(mark(z0), z1, z2, z3)), MARK(u(z0, z1, z2, z3)))
   MARK(tail(head(z0))) -> c33(A__TAIL(a__head(mark(z0))), MARK(head(z0)))
   MARK(tail(tail(z0))) -> c33(A__TAIL(a__tail(mark(z0))), MARK(tail(z0)))
   MARK(tail(sel(z0, z1))) -> c33(A__TAIL(a__sel(mark(z0), mark(z1))), MARK(sel(z0, z1)))
   MARK(tail(afterNth(z0, z1))) -> c33(A__TAIL(a__afterNth(mark(z0), mark(z1))), MARK(afterNth(z0, z1)))
   MARK(tail(take(z0, z1))) -> c33(A__TAIL(a__take(mark(z0), mark(z1))), MARK(take(z0, z1)))
   MARK(tail(cons(z0, z1))) -> c33(A__TAIL(cons(mark(z0), z1)), MARK(cons(z0, z1)))
   MARK(tail(s(z0))) -> c33(MARK(s(z0)))
   MARK(tail(pair(z0, z1))) -> c33(MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), cons(mark(mark(x2)), natsFrom(s(mark(x2))))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(mark(x0), natsFrom(mark(x2))), x0, x1, natsFrom(x2)), A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__natsFrom(mark(z0)))), x0, x1, natsFrom(natsFrom(z0))), A__SPLITAT(mark(x0), mark(natsFrom(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__fst(mark(z0)))), x0, x1, natsFrom(fst(z0))), A__SPLITAT(mark(x0), mark(natsFrom(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__snd(mark(z0)))), x0, x1, natsFrom(snd(z0))), A__SPLITAT(mark(x0), mark(natsFrom(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__splitAt(mark(z0), mark(z1)))), x0, x1, natsFrom(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__u(mark(z0), z1, z2, z3))), x0, x1, natsFrom(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(natsFrom(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__head(mark(z0)))), x0, x1, natsFrom(head(z0))), A__SPLITAT(mark(x0), mark(natsFrom(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__tail(mark(z0)))), x0, x1, natsFrom(tail(z0))), A__SPLITAT(mark(x0), mark(natsFrom(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__sel(mark(z0), mark(z1)))), x0, x1, natsFrom(sel(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__afterNth(mark(z0), mark(z1)))), x0, x1, natsFrom(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(a__take(mark(z0), mark(z1)))), x0, x1, natsFrom(take(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(cons(mark(z0), z1))), x0, x1, natsFrom(cons(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(s(mark(z0)))), x0, x1, natsFrom(s(z0))), A__SPLITAT(mark(x0), mark(natsFrom(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(pair(mark(z0), mark(z1)))), x0, x1, natsFrom(pair(z0, z1))), A__SPLITAT(mark(x0), mark(natsFrom(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(0))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(0)), x0, x1, natsFrom(0)), A__SPLITAT(mark(x0), mark(natsFrom(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, natsFrom(nil))) -> c7(A__U(a__splitAt(mark(x0), a__natsFrom(nil)), x0, x1, natsFrom(nil)), A__SPLITAT(mark(x0), mark(natsFrom(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__natsFrom(mark(x2))), natsFrom(z0), x1, natsFrom(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(natsFrom(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__natsFrom(mark(x2))), fst(z0), x1, natsFrom(x2)), A__SPLITAT(mark(fst(z0)), mark(natsFrom(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__natsFrom(mark(x2))), snd(z0), x1, natsFrom(x2)), A__SPLITAT(mark(snd(z0)), mark(natsFrom(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__natsFrom(mark(x2))), splitAt(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(natsFrom(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__natsFrom(mark(x2))), u(z0, z1, z2, z3), x1, natsFrom(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(natsFrom(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__natsFrom(mark(x2))), head(z0), x1, natsFrom(x2)), A__SPLITAT(mark(head(z0)), mark(natsFrom(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__natsFrom(mark(x2))), tail(z0), x1, natsFrom(x2)), A__SPLITAT(mark(tail(z0)), mark(natsFrom(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__natsFrom(mark(x2))), sel(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(natsFrom(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__natsFrom(mark(x2))), afterNth(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(natsFrom(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__natsFrom(mark(x2))), take(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(take(z0, z1)), mark(natsFrom(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__natsFrom(mark(x2))), cons(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(natsFrom(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__natsFrom(mark(x2))), s(z0), x1, natsFrom(x2)), A__SPLITAT(mark(s(z0)), mark(natsFrom(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__natsFrom(mark(x2))), pair(z0, z1), x1, natsFrom(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(natsFrom(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, natsFrom(x2))) -> c7(A__SPLITAT(mark(x0), mark(natsFrom(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(0, a__natsFrom(mark(x2))), 0, x1, natsFrom(x2)), A__SPLITAT(mark(0), mark(natsFrom(x2))))
   A__SPLITAT(s(nil), cons(x1, natsFrom(x2))) -> c7(A__U(a__splitAt(nil, a__natsFrom(mark(x2))), nil, x1, natsFrom(x2)), A__SPLITAT(mark(nil), mark(natsFrom(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(mark(x0), fst(mark(x2))), x0, x1, fst(x2)), A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__natsFrom(mark(z0)))), x0, x1, fst(natsFrom(z0))), A__SPLITAT(mark(x0), mark(fst(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__fst(mark(z0)))), x0, x1, fst(fst(z0))), A__SPLITAT(mark(x0), mark(fst(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__snd(mark(z0)))), x0, x1, fst(snd(z0))), A__SPLITAT(mark(x0), mark(fst(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(z0), mark(z1)))), x0, x1, fst(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(fst(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__u(mark(z0), z1, z2, z3))), x0, x1, fst(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(fst(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__head(mark(z0)))), x0, x1, fst(head(z0))), A__SPLITAT(mark(x0), mark(fst(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__tail(mark(z0)))), x0, x1, fst(tail(z0))), A__SPLITAT(mark(x0), mark(fst(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__sel(mark(z0), mark(z1)))), x0, x1, fst(sel(z0, z1))), A__SPLITAT(mark(x0), mark(fst(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__afterNth(mark(z0), mark(z1)))), x0, x1, fst(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(fst(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__take(mark(z0), mark(z1)))), x0, x1, fst(take(z0, z1))), A__SPLITAT(mark(x0), mark(fst(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(cons(mark(z0), z1))), x0, x1, fst(cons(z0, z1))), A__SPLITAT(mark(x0), mark(fst(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(s(mark(z0)))), x0, x1, fst(s(z0))), A__SPLITAT(mark(x0), mark(fst(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__fst(pair(mark(z0), mark(z1)))), x0, x1, fst(pair(z0, z1))), A__SPLITAT(mark(x0), mark(fst(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(0))) -> c7(A__U(a__splitAt(mark(x0), a__fst(0)), x0, x1, fst(0)), A__SPLITAT(mark(x0), mark(fst(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, fst(nil))) -> c7(A__U(a__splitAt(mark(x0), a__fst(nil)), x0, x1, fst(nil)), A__SPLITAT(mark(x0), mark(fst(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__fst(mark(x2))), natsFrom(z0), x1, fst(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(fst(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__fst(mark(x2))), fst(z0), x1, fst(x2)), A__SPLITAT(mark(fst(z0)), mark(fst(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__fst(mark(x2))), snd(z0), x1, fst(x2)), A__SPLITAT(mark(snd(z0)), mark(fst(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__fst(mark(x2))), splitAt(z0, z1), x1, fst(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(fst(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__fst(mark(x2))), u(z0, z1, z2, z3), x1, fst(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(fst(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__fst(mark(x2))), head(z0), x1, fst(x2)), A__SPLITAT(mark(head(z0)), mark(fst(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__fst(mark(x2))), tail(z0), x1, fst(x2)), A__SPLITAT(mark(tail(z0)), mark(fst(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__fst(mark(x2))), sel(z0, z1), x1, fst(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(fst(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__fst(mark(x2))), afterNth(z0, z1), x1, fst(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(fst(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__fst(mark(x2))), take(z0, z1), x1, fst(x2)), A__SPLITAT(mark(take(z0, z1)), mark(fst(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__fst(mark(x2))), cons(z0, z1), x1, fst(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(fst(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__fst(mark(x2))), s(z0), x1, fst(x2)), A__SPLITAT(mark(s(z0)), mark(fst(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__fst(mark(x2))), pair(z0, z1), x1, fst(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(fst(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, fst(x2))) -> c7(A__SPLITAT(mark(x0), mark(fst(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(0, a__fst(mark(x2))), 0, x1, fst(x2)), A__SPLITAT(mark(0), mark(fst(x2))))
   A__SPLITAT(s(nil), cons(x1, fst(x2))) -> c7(A__U(a__splitAt(nil, a__fst(mark(x2))), nil, x1, fst(x2)), A__SPLITAT(mark(nil), mark(fst(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(mark(x0), snd(mark(x2))), x0, x1, snd(x2)), A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__natsFrom(mark(z0)))), x0, x1, snd(natsFrom(z0))), A__SPLITAT(mark(x0), mark(snd(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__fst(mark(z0)))), x0, x1, snd(fst(z0))), A__SPLITAT(mark(x0), mark(snd(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__snd(mark(z0)))), x0, x1, snd(snd(z0))), A__SPLITAT(mark(x0), mark(snd(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(z0), mark(z1)))), x0, x1, snd(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(snd(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__u(mark(z0), z1, z2, z3))), x0, x1, snd(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(snd(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__head(mark(z0)))), x0, x1, snd(head(z0))), A__SPLITAT(mark(x0), mark(snd(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__tail(mark(z0)))), x0, x1, snd(tail(z0))), A__SPLITAT(mark(x0), mark(snd(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__sel(mark(z0), mark(z1)))), x0, x1, snd(sel(z0, z1))), A__SPLITAT(mark(x0), mark(snd(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__afterNth(mark(z0), mark(z1)))), x0, x1, snd(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(snd(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__take(mark(z0), mark(z1)))), x0, x1, snd(take(z0, z1))), A__SPLITAT(mark(x0), mark(snd(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(cons(mark(z0), z1))), x0, x1, snd(cons(z0, z1))), A__SPLITAT(mark(x0), mark(snd(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(s(mark(z0)))), x0, x1, snd(s(z0))), A__SPLITAT(mark(x0), mark(snd(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__snd(pair(mark(z0), mark(z1)))), x0, x1, snd(pair(z0, z1))), A__SPLITAT(mark(x0), mark(snd(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(0))) -> c7(A__U(a__splitAt(mark(x0), a__snd(0)), x0, x1, snd(0)), A__SPLITAT(mark(x0), mark(snd(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, snd(nil))) -> c7(A__U(a__splitAt(mark(x0), a__snd(nil)), x0, x1, snd(nil)), A__SPLITAT(mark(x0), mark(snd(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__snd(mark(x2))), natsFrom(z0), x1, snd(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(snd(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__snd(mark(x2))), fst(z0), x1, snd(x2)), A__SPLITAT(mark(fst(z0)), mark(snd(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__snd(mark(x2))), snd(z0), x1, snd(x2)), A__SPLITAT(mark(snd(z0)), mark(snd(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__snd(mark(x2))), splitAt(z0, z1), x1, snd(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(snd(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__snd(mark(x2))), u(z0, z1, z2, z3), x1, snd(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(snd(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__snd(mark(x2))), head(z0), x1, snd(x2)), A__SPLITAT(mark(head(z0)), mark(snd(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__snd(mark(x2))), tail(z0), x1, snd(x2)), A__SPLITAT(mark(tail(z0)), mark(snd(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__snd(mark(x2))), sel(z0, z1), x1, snd(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(snd(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__snd(mark(x2))), afterNth(z0, z1), x1, snd(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(snd(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__snd(mark(x2))), take(z0, z1), x1, snd(x2)), A__SPLITAT(mark(take(z0, z1)), mark(snd(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__snd(mark(x2))), cons(z0, z1), x1, snd(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(snd(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__snd(mark(x2))), s(z0), x1, snd(x2)), A__SPLITAT(mark(s(z0)), mark(snd(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__snd(mark(x2))), pair(z0, z1), x1, snd(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(snd(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, snd(x2))) -> c7(A__SPLITAT(mark(x0), mark(snd(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(0, a__snd(mark(x2))), 0, x1, snd(x2)), A__SPLITAT(mark(0), mark(snd(x2))))
   A__SPLITAT(s(nil), cons(x1, snd(x2))) -> c7(A__U(a__splitAt(nil, a__snd(mark(x2))), nil, x1, snd(x2)), A__SPLITAT(mark(nil), mark(snd(x2))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), splitAt(mark(x2), mark(x3))), x0, x1, splitAt(x2, x3)), A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__natsFrom(mark(z0)))), x0, x1, splitAt(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__fst(mark(z0)))), x0, x1, splitAt(x2, fst(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__snd(mark(z0)))), x0, x1, splitAt(x2, snd(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, splitAt(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, splitAt(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(splitAt(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__head(mark(z0)))), x0, x1, splitAt(x2, head(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__tail(mark(z0)))), x0, x1, splitAt(x2, tail(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, splitAt(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, splitAt(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, splitAt(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), cons(mark(z0), z1))), x0, x1, splitAt(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), s(mark(z0)))), x0, x1, splitAt(x2, s(z0))), A__SPLITAT(mark(x0), mark(splitAt(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, splitAt(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(splitAt(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), 0)), x0, x1, splitAt(x2, 0)), A__SPLITAT(mark(x0), mark(splitAt(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(mark(x2), nil)), x0, x1, splitAt(x2, nil)), A__SPLITAT(mark(x0), mark(splitAt(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__natsFrom(mark(z0)), mark(x3))), x0, x1, splitAt(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__fst(mark(z0)), mark(x3))), x0, x1, splitAt(fst(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__snd(mark(z0)), mark(x3))), x0, x1, splitAt(snd(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, splitAt(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(splitAt(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__head(mark(z0)), mark(x3))), x0, x1, splitAt(head(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__tail(mark(z0)), mark(x3))), x0, x1, splitAt(tail(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(cons(mark(z0), z1), mark(x3))), x0, x1, splitAt(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(s(mark(z0)), mark(x3))), x0, x1, splitAt(s(z0), x3)), A__SPLITAT(mark(x0), mark(splitAt(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, splitAt(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(splitAt(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(0, mark(x3))), x0, x1, splitAt(0, x3)), A__SPLITAT(mark(x0), mark(splitAt(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, splitAt(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__splitAt(nil, mark(x3))), x0, x1, splitAt(nil, x3)), A__SPLITAT(mark(x0), mark(splitAt(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__splitAt(mark(x2), mark(x3))), natsFrom(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(splitAt(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__splitAt(mark(x2), mark(x3))), fst(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(splitAt(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__splitAt(mark(x2), mark(x3))), snd(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(splitAt(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), splitAt(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(splitAt(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__splitAt(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, splitAt(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(splitAt(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__splitAt(mark(x2), mark(x3))), head(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(head(z0)), mark(splitAt(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__splitAt(mark(x2), mark(x3))), tail(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(splitAt(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), sel(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(splitAt(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), afterNth(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(splitAt(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), take(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(splitAt(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__splitAt(mark(x2), mark(x3))), cons(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(splitAt(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__splitAt(mark(x2), mark(x3))), s(z0), x1, splitAt(x2, x3)), A__SPLITAT(mark(s(z0)), mark(splitAt(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__splitAt(mark(x2), mark(x3))), pair(z0, z1), x1, splitAt(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(splitAt(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, splitAt(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(splitAt(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(0, a__splitAt(mark(x2), mark(x3))), 0, x1, splitAt(x2, x3)), A__SPLITAT(mark(0), mark(splitAt(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, splitAt(x2, x3))) -> c7(A__U(a__splitAt(nil, a__splitAt(mark(x2), mark(x3))), nil, x1, splitAt(x2, x3)), A__SPLITAT(mark(nil), mark(splitAt(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, u(x2, z1, z2, z3))) -> c7(A__U(a__splitAt(mark(x0), u(mark(x2), z1, z2, z3)), x0, x1, u(x2, z1, z2, z3)), A__SPLITAT(mark(x0), mark(u(x2, z1, z2, z3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(natsFrom(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__natsFrom(mark(z0)), x3, x4, x5)), x0, x1, u(natsFrom(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(natsFrom(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(fst(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__fst(mark(z0)), x3, x4, x5)), x0, x1, u(fst(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(fst(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(snd(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__snd(mark(z0)), x3, x4, x5)), x0, x1, u(snd(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(snd(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(splitAt(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__splitAt(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(splitAt(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(splitAt(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(u(z0, z1, z2, z3), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__u(mark(z0), z1, z2, z3), x3, x4, x5)), x0, x1, u(u(z0, z1, z2, z3), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(u(z0, z1, z2, z3), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(head(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__head(mark(z0)), x3, x4, x5)), x0, x1, u(head(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(head(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(tail(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__tail(mark(z0)), x3, x4, x5)), x0, x1, u(tail(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(tail(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(sel(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__sel(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(sel(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(sel(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(afterNth(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__afterNth(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(afterNth(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(afterNth(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(take(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(a__take(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(take(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(take(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(cons(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(cons(mark(z0), z1), x3, x4, x5)), x0, x1, u(cons(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(cons(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(s(z0), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(s(mark(z0)), x3, x4, x5)), x0, x1, u(s(z0), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(s(z0), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(pair(z0, z1), x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(pair(mark(z0), mark(z1)), x3, x4, x5)), x0, x1, u(pair(z0, z1), x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(pair(z0, z1), x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(0, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(0, x3, x4, x5)), x0, x1, u(0, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(0, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, u(nil, x3, x4, x5))) -> c7(A__U(a__splitAt(mark(x0), a__u(nil, x3, x4, x5)), x0, x1, u(nil, x3, x4, x5)), A__SPLITAT(mark(x0), mark(u(nil, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__u(mark(x2), x3, x4, x5)), natsFrom(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(natsFrom(z0)), mark(u(x2, x3, x4, x5))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__u(mark(x2), x3, x4, x5)), fst(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(fst(z0)), mark(u(x2, x3, x4, x5))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__u(mark(x2), x3, x4, x5)), snd(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(snd(z0)), mark(u(x2, x3, x4, x5))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), splitAt(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(splitAt(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__u(mark(x2), x3, x4, x5)), u(z0, z1, z2, z3), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(u(x2, x3, x4, x5))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__u(mark(x2), x3, x4, x5)), head(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(head(z0)), mark(u(x2, x3, x4, x5))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__u(mark(x2), x3, x4, x5)), tail(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(tail(z0)), mark(u(x2, x3, x4, x5))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), sel(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(sel(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), afterNth(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(afterNth(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), take(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(take(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__u(mark(x2), x3, x4, x5)), cons(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(cons(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(s(mark(z0)), a__u(mark(x2), x3, x4, x5)), s(z0), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(s(z0)), mark(u(x2, x3, x4, x5))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__u(mark(x2), x3, x4, x5)), pair(z0, z1), x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(pair(z0, z1)), mark(u(x2, x3, x4, x5))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__SPLITAT(mark(x0), mark(u(x2, x3, x4, x5))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(0, a__u(mark(x2), x3, x4, x5)), 0, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(0), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(nil), cons(x1, u(x2, x3, x4, x5))) -> c7(A__U(a__splitAt(nil, a__u(mark(x2), x3, x4, x5)), nil, x1, u(x2, x3, x4, x5)), A__SPLITAT(mark(nil), mark(u(x2, x3, x4, x5))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(mark(x0), head(mark(x2))), x0, x1, head(x2)), A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__natsFrom(mark(z0)))), x0, x1, head(natsFrom(z0))), A__SPLITAT(mark(x0), mark(head(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__fst(mark(z0)))), x0, x1, head(fst(z0))), A__SPLITAT(mark(x0), mark(head(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__snd(mark(z0)))), x0, x1, head(snd(z0))), A__SPLITAT(mark(x0), mark(head(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__splitAt(mark(z0), mark(z1)))), x0, x1, head(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(head(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__u(mark(z0), z1, z2, z3))), x0, x1, head(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(head(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__head(mark(z0)))), x0, x1, head(head(z0))), A__SPLITAT(mark(x0), mark(head(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__tail(mark(z0)))), x0, x1, head(tail(z0))), A__SPLITAT(mark(x0), mark(head(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__sel(mark(z0), mark(z1)))), x0, x1, head(sel(z0, z1))), A__SPLITAT(mark(x0), mark(head(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(z0), mark(z1)))), x0, x1, head(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(head(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__take(mark(z0), mark(z1)))), x0, x1, head(take(z0, z1))), A__SPLITAT(mark(x0), mark(head(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(cons(mark(z0), z1))), x0, x1, head(cons(z0, z1))), A__SPLITAT(mark(x0), mark(head(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__head(s(mark(z0)))), x0, x1, head(s(z0))), A__SPLITAT(mark(x0), mark(head(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__head(pair(mark(z0), mark(z1)))), x0, x1, head(pair(z0, z1))), A__SPLITAT(mark(x0), mark(head(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(0))) -> c7(A__U(a__splitAt(mark(x0), a__head(0)), x0, x1, head(0)), A__SPLITAT(mark(x0), mark(head(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, head(nil))) -> c7(A__U(a__splitAt(mark(x0), a__head(nil)), x0, x1, head(nil)), A__SPLITAT(mark(x0), mark(head(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__head(mark(x2))), natsFrom(z0), x1, head(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(head(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__head(mark(x2))), fst(z0), x1, head(x2)), A__SPLITAT(mark(fst(z0)), mark(head(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__head(mark(x2))), snd(z0), x1, head(x2)), A__SPLITAT(mark(snd(z0)), mark(head(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__head(mark(x2))), splitAt(z0, z1), x1, head(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(head(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__head(mark(x2))), u(z0, z1, z2, z3), x1, head(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(head(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__head(mark(x2))), head(z0), x1, head(x2)), A__SPLITAT(mark(head(z0)), mark(head(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__head(mark(x2))), tail(z0), x1, head(x2)), A__SPLITAT(mark(tail(z0)), mark(head(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__head(mark(x2))), sel(z0, z1), x1, head(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(head(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__head(mark(x2))), afterNth(z0, z1), x1, head(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(head(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__head(mark(x2))), take(z0, z1), x1, head(x2)), A__SPLITAT(mark(take(z0, z1)), mark(head(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__head(mark(x2))), cons(z0, z1), x1, head(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(head(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__head(mark(x2))), s(z0), x1, head(x2)), A__SPLITAT(mark(s(z0)), mark(head(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, head(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__head(mark(x2))), pair(z0, z1), x1, head(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(head(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, head(x2))) -> c7(A__SPLITAT(mark(x0), mark(head(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, head(x2))) -> c7(A__U(a__splitAt(0, a__head(mark(x2))), 0, x1, head(x2)), A__SPLITAT(mark(0), mark(head(x2))))
   A__SPLITAT(s(nil), cons(x1, head(x2))) -> c7(A__U(a__splitAt(nil, a__head(mark(x2))), nil, x1, head(x2)), A__SPLITAT(mark(nil), mark(head(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(mark(x0), tail(mark(x2))), x0, x1, tail(x2)), A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__natsFrom(mark(z0)))), x0, x1, tail(natsFrom(z0))), A__SPLITAT(mark(x0), mark(tail(natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__fst(mark(z0)))), x0, x1, tail(fst(z0))), A__SPLITAT(mark(x0), mark(tail(fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__snd(mark(z0)))), x0, x1, tail(snd(z0))), A__SPLITAT(mark(x0), mark(tail(snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__splitAt(mark(z0), mark(z1)))), x0, x1, tail(splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(tail(splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__u(mark(z0), z1, z2, z3))), x0, x1, tail(u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(tail(u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__head(mark(z0)))), x0, x1, tail(head(z0))), A__SPLITAT(mark(x0), mark(tail(head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__tail(mark(z0)))), x0, x1, tail(tail(z0))), A__SPLITAT(mark(x0), mark(tail(tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__sel(mark(z0), mark(z1)))), x0, x1, tail(sel(z0, z1))), A__SPLITAT(mark(x0), mark(tail(sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__afterNth(mark(z0), mark(z1)))), x0, x1, tail(afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(tail(afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(a__take(mark(z0), mark(z1)))), x0, x1, tail(take(z0, z1))), A__SPLITAT(mark(x0), mark(tail(take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(cons(mark(z0), z1))), x0, x1, tail(cons(z0, z1))), A__SPLITAT(mark(x0), mark(tail(cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(s(mark(z0)))), x0, x1, tail(s(z0))), A__SPLITAT(mark(x0), mark(tail(s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__tail(pair(mark(z0), mark(z1)))), x0, x1, tail(pair(z0, z1))), A__SPLITAT(mark(x0), mark(tail(pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(0))) -> c7(A__U(a__splitAt(mark(x0), a__tail(0)), x0, x1, tail(0)), A__SPLITAT(mark(x0), mark(tail(0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, tail(nil))) -> c7(A__U(a__splitAt(mark(x0), a__tail(nil)), x0, x1, tail(nil)), A__SPLITAT(mark(x0), mark(tail(nil))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__tail(mark(x2))), natsFrom(z0), x1, tail(x2)), A__SPLITAT(mark(natsFrom(z0)), mark(tail(x2))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__tail(mark(x2))), fst(z0), x1, tail(x2)), A__SPLITAT(mark(fst(z0)), mark(tail(x2))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__tail(mark(x2))), snd(z0), x1, tail(x2)), A__SPLITAT(mark(snd(z0)), mark(tail(x2))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__tail(mark(x2))), splitAt(z0, z1), x1, tail(x2)), A__SPLITAT(mark(splitAt(z0, z1)), mark(tail(x2))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__tail(mark(x2))), u(z0, z1, z2, z3), x1, tail(x2)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(tail(x2))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__tail(mark(x2))), head(z0), x1, tail(x2)), A__SPLITAT(mark(head(z0)), mark(tail(x2))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__tail(mark(x2))), tail(z0), x1, tail(x2)), A__SPLITAT(mark(tail(z0)), mark(tail(x2))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__tail(mark(x2))), sel(z0, z1), x1, tail(x2)), A__SPLITAT(mark(sel(z0, z1)), mark(tail(x2))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__tail(mark(x2))), afterNth(z0, z1), x1, tail(x2)), A__SPLITAT(mark(afterNth(z0, z1)), mark(tail(x2))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__tail(mark(x2))), take(z0, z1), x1, tail(x2)), A__SPLITAT(mark(take(z0, z1)), mark(tail(x2))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__tail(mark(x2))), cons(z0, z1), x1, tail(x2)), A__SPLITAT(mark(cons(z0, z1)), mark(tail(x2))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(s(mark(z0)), a__tail(mark(x2))), s(z0), x1, tail(x2)), A__SPLITAT(mark(s(z0)), mark(tail(x2))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__tail(mark(x2))), pair(z0, z1), x1, tail(x2)), A__SPLITAT(mark(pair(z0, z1)), mark(tail(x2))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, tail(x2))) -> c7(A__SPLITAT(mark(x0), mark(tail(x2))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(0, a__tail(mark(x2))), 0, x1, tail(x2)), A__SPLITAT(mark(0), mark(tail(x2))))
   A__SPLITAT(s(nil), cons(x1, tail(x2))) -> c7(A__U(a__splitAt(nil, a__tail(mark(x2))), nil, x1, tail(x2)), A__SPLITAT(mark(nil), mark(tail(x2))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__head(a__afterNth(mark(mark(x2)), mark(mark(x3))))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), sel(mark(x2), mark(x3))), x0, x1, sel(x2, x3)), A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__natsFrom(mark(z0)))), x0, x1, sel(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(sel(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__fst(mark(z0)))), x0, x1, sel(x2, fst(z0))), A__SPLITAT(mark(x0), mark(sel(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__snd(mark(z0)))), x0, x1, sel(x2, snd(z0))), A__SPLITAT(mark(x0), mark(sel(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, sel(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, sel(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(sel(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__head(mark(z0)))), x0, x1, sel(x2, head(z0))), A__SPLITAT(mark(x0), mark(sel(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__tail(mark(z0)))), x0, x1, sel(x2, tail(z0))), A__SPLITAT(mark(x0), mark(sel(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, sel(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, sel(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, sel(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), cons(mark(z0), z1))), x0, x1, sel(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), s(mark(z0)))), x0, x1, sel(x2, s(z0))), A__SPLITAT(mark(x0), mark(sel(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, sel(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(sel(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), 0)), x0, x1, sel(x2, 0)), A__SPLITAT(mark(x0), mark(sel(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__sel(mark(x2), nil)), x0, x1, sel(x2, nil)), A__SPLITAT(mark(x0), mark(sel(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__natsFrom(mark(z0)), mark(x3))), x0, x1, sel(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(sel(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__fst(mark(z0)), mark(x3))), x0, x1, sel(fst(z0), x3)), A__SPLITAT(mark(x0), mark(sel(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__snd(mark(z0)), mark(x3))), x0, x1, sel(snd(z0), x3)), A__SPLITAT(mark(x0), mark(sel(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, sel(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(sel(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__head(mark(z0)), mark(x3))), x0, x1, sel(head(z0), x3)), A__SPLITAT(mark(x0), mark(sel(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__tail(mark(z0)), mark(x3))), x0, x1, sel(tail(z0), x3)), A__SPLITAT(mark(x0), mark(sel(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(cons(mark(z0), z1), mark(x3))), x0, x1, sel(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(s(mark(z0)), mark(x3))), x0, x1, sel(s(z0), x3)), A__SPLITAT(mark(x0), mark(sel(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, sel(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(sel(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(0, mark(x3))), x0, x1, sel(0, x3)), A__SPLITAT(mark(x0), mark(sel(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, sel(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__sel(nil, mark(x3))), x0, x1, sel(nil, x3)), A__SPLITAT(mark(x0), mark(sel(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__sel(mark(x2), mark(x3))), natsFrom(z0), x1, sel(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(sel(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__sel(mark(x2), mark(x3))), fst(z0), x1, sel(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(sel(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__sel(mark(x2), mark(x3))), snd(z0), x1, sel(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(sel(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), splitAt(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(sel(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__sel(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, sel(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(sel(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__sel(mark(x2), mark(x3))), head(z0), x1, sel(x2, x3)), A__SPLITAT(mark(head(z0)), mark(sel(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__sel(mark(x2), mark(x3))), tail(z0), x1, sel(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(sel(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), sel(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(sel(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), afterNth(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(sel(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), take(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(sel(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__sel(mark(x2), mark(x3))), cons(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(sel(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__sel(mark(x2), mark(x3))), s(z0), x1, sel(x2, x3)), A__SPLITAT(mark(s(z0)), mark(sel(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__sel(mark(x2), mark(x3))), pair(z0, z1), x1, sel(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(sel(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, sel(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(sel(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(0, a__sel(mark(x2), mark(x3))), 0, x1, sel(x2, x3)), A__SPLITAT(mark(0), mark(sel(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, sel(x2, x3))) -> c7(A__U(a__splitAt(nil, a__sel(mark(x2), mark(x3))), nil, x1, sel(x2, x3)), A__SPLITAT(mark(nil), mark(sel(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__snd(a__splitAt(mark(mark(x2)), mark(mark(x3))))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), afterNth(mark(x2), mark(x3))), x0, x1, afterNth(x2, x3)), A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__natsFrom(mark(z0)))), x0, x1, afterNth(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__fst(mark(z0)))), x0, x1, afterNth(x2, fst(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__snd(mark(z0)))), x0, x1, afterNth(x2, snd(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, afterNth(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, afterNth(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(afterNth(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__head(mark(z0)))), x0, x1, afterNth(x2, head(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__tail(mark(z0)))), x0, x1, afterNth(x2, tail(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, afterNth(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, afterNth(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, afterNth(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), cons(mark(z0), z1))), x0, x1, afterNth(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), s(mark(z0)))), x0, x1, afterNth(x2, s(z0))), A__SPLITAT(mark(x0), mark(afterNth(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, afterNth(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(afterNth(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), 0)), x0, x1, afterNth(x2, 0)), A__SPLITAT(mark(x0), mark(afterNth(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(mark(x2), nil)), x0, x1, afterNth(x2, nil)), A__SPLITAT(mark(x0), mark(afterNth(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__natsFrom(mark(z0)), mark(x3))), x0, x1, afterNth(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__fst(mark(z0)), mark(x3))), x0, x1, afterNth(fst(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__snd(mark(z0)), mark(x3))), x0, x1, afterNth(snd(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, afterNth(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(afterNth(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__head(mark(z0)), mark(x3))), x0, x1, afterNth(head(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__tail(mark(z0)), mark(x3))), x0, x1, afterNth(tail(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(cons(mark(z0), z1), mark(x3))), x0, x1, afterNth(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(s(mark(z0)), mark(x3))), x0, x1, afterNth(s(z0), x3)), A__SPLITAT(mark(x0), mark(afterNth(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, afterNth(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(afterNth(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(0, mark(x3))), x0, x1, afterNth(0, x3)), A__SPLITAT(mark(x0), mark(afterNth(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, afterNth(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__afterNth(nil, mark(x3))), x0, x1, afterNth(nil, x3)), A__SPLITAT(mark(x0), mark(afterNth(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__afterNth(mark(x2), mark(x3))), natsFrom(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(afterNth(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__afterNth(mark(x2), mark(x3))), fst(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(afterNth(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__afterNth(mark(x2), mark(x3))), snd(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(afterNth(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), splitAt(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(afterNth(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__afterNth(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, afterNth(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(afterNth(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__afterNth(mark(x2), mark(x3))), head(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(head(z0)), mark(afterNth(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__afterNth(mark(x2), mark(x3))), tail(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(afterNth(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), sel(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(afterNth(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), afterNth(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(afterNth(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), take(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(afterNth(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__afterNth(mark(x2), mark(x3))), cons(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(afterNth(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__afterNth(mark(x2), mark(x3))), s(z0), x1, afterNth(x2, x3)), A__SPLITAT(mark(s(z0)), mark(afterNth(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__afterNth(mark(x2), mark(x3))), pair(z0, z1), x1, afterNth(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(afterNth(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(afterNth(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, afterNth(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(afterNth(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(0, a__afterNth(mark(x2), mark(x3))), 0, x1, afterNth(x2, x3)), A__SPLITAT(mark(0), mark(afterNth(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, afterNth(x2, x3))) -> c7(A__U(a__splitAt(nil, a__afterNth(mark(x2), mark(x3))), nil, x1, afterNth(x2, x3)), A__SPLITAT(mark(nil), mark(afterNth(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), a__fst(a__splitAt(mark(mark(x2)), mark(mark(x3))))), x0, x1, take(x2, x3)), A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(mark(x0), take(mark(x2), mark(x3))), x0, x1, take(x2, x3)), A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, natsFrom(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__natsFrom(mark(z0)))), x0, x1, take(x2, natsFrom(z0))), A__SPLITAT(mark(x0), mark(take(x2, natsFrom(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, fst(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__fst(mark(z0)))), x0, x1, take(x2, fst(z0))), A__SPLITAT(mark(x0), mark(take(x2, fst(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, snd(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__snd(mark(z0)))), x0, x1, take(x2, snd(z0))), A__SPLITAT(mark(x0), mark(take(x2, snd(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, splitAt(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__splitAt(mark(z0), mark(z1)))), x0, x1, take(x2, splitAt(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, splitAt(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, u(z0, z1, z2, z3)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__u(mark(z0), z1, z2, z3))), x0, x1, take(x2, u(z0, z1, z2, z3))), A__SPLITAT(mark(x0), mark(take(x2, u(z0, z1, z2, z3)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, head(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__head(mark(z0)))), x0, x1, take(x2, head(z0))), A__SPLITAT(mark(x0), mark(take(x2, head(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, tail(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__tail(mark(z0)))), x0, x1, take(x2, tail(z0))), A__SPLITAT(mark(x0), mark(take(x2, tail(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, sel(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__sel(mark(z0), mark(z1)))), x0, x1, take(x2, sel(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, sel(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, afterNth(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__afterNth(mark(z0), mark(z1)))), x0, x1, take(x2, afterNth(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, afterNth(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, take(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), a__take(mark(z0), mark(z1)))), x0, x1, take(x2, take(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, take(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, cons(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), cons(mark(z0), z1))), x0, x1, take(x2, cons(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, cons(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, s(z0)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), s(mark(z0)))), x0, x1, take(x2, s(z0))), A__SPLITAT(mark(x0), mark(take(x2, s(z0)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, pair(z0, z1)))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), pair(mark(z0), mark(z1)))), x0, x1, take(x2, pair(z0, z1))), A__SPLITAT(mark(x0), mark(take(x2, pair(z0, z1)))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, 0))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), 0)), x0, x1, take(x2, 0)), A__SPLITAT(mark(x0), mark(take(x2, 0))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(x2, nil))) -> c7(A__U(a__splitAt(mark(x0), a__take(mark(x2), nil)), x0, x1, take(x2, nil)), A__SPLITAT(mark(x0), mark(take(x2, nil))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__natsFrom(mark(z0)), mark(x3))), x0, x1, take(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(take(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__fst(mark(z0)), mark(x3))), x0, x1, take(fst(z0), x3)), A__SPLITAT(mark(x0), mark(take(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__snd(mark(z0)), mark(x3))), x0, x1, take(snd(z0), x3)), A__SPLITAT(mark(x0), mark(take(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__splitAt(mark(z0), mark(z1)), mark(x3))), x0, x1, take(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__u(mark(z0), z1, z2, z3), mark(x3))), x0, x1, take(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(take(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__head(mark(z0)), mark(x3))), x0, x1, take(head(z0), x3)), A__SPLITAT(mark(x0), mark(take(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__tail(mark(z0)), mark(x3))), x0, x1, take(tail(z0), x3)), A__SPLITAT(mark(x0), mark(take(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__sel(mark(z0), mark(z1)), mark(x3))), x0, x1, take(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__afterNth(mark(z0), mark(z1)), mark(x3))), x0, x1, take(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(a__take(mark(z0), mark(z1)), mark(x3))), x0, x1, take(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(cons(mark(z0), z1), mark(x3))), x0, x1, take(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(s(mark(z0)), mark(x3))), x0, x1, take(s(z0), x3)), A__SPLITAT(mark(x0), mark(take(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(pair(mark(z0), mark(z1)), mark(x3))), x0, x1, take(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(take(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(0, x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(0, mark(x3))), x0, x1, take(0, x3)), A__SPLITAT(mark(x0), mark(take(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, take(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), a__take(nil, mark(x3))), x0, x1, take(nil, x3)), A__SPLITAT(mark(x0), mark(take(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), a__take(mark(x2), mark(x3))), natsFrom(z0), x1, take(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(take(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), a__take(mark(x2), mark(x3))), fst(z0), x1, take(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(take(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), a__take(mark(x2), mark(x3))), snd(z0), x1, take(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(take(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), splitAt(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(take(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), a__take(mark(x2), mark(x3))), u(z0, z1, z2, z3), x1, take(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(take(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), a__take(mark(x2), mark(x3))), head(z0), x1, take(x2, x3)), A__SPLITAT(mark(head(z0)), mark(take(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), a__take(mark(x2), mark(x3))), tail(z0), x1, take(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(take(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), sel(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(take(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), afterNth(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(take(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), take(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(take(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), a__take(mark(x2), mark(x3))), cons(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(take(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), a__take(mark(x2), mark(x3))), s(z0), x1, take(x2, x3)), A__SPLITAT(mark(s(z0)), mark(take(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), a__take(mark(x2), mark(x3))), pair(z0, z1), x1, take(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(take(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(take(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, take(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(take(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(0, a__take(mark(x2), mark(x3))), 0, x1, take(x2, x3)), A__SPLITAT(mark(0), mark(take(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, take(x2, x3))) -> c7(A__U(a__splitAt(nil, a__take(mark(x2), mark(x3))), nil, x1, take(x2, x3)), A__SPLITAT(mark(nil), mark(take(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, cons(natsFrom(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__natsFrom(mark(z0)), x3)), x0, x1, cons(natsFrom(z0), x3)), A__SPLITAT(mark(x0), mark(cons(natsFrom(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(fst(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__fst(mark(z0)), x3)), x0, x1, cons(fst(z0), x3)), A__SPLITAT(mark(x0), mark(cons(fst(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(snd(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__snd(mark(z0)), x3)), x0, x1, cons(snd(z0), x3)), A__SPLITAT(mark(x0), mark(cons(snd(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(splitAt(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__splitAt(mark(z0), mark(z1)), x3)), x0, x1, cons(splitAt(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(splitAt(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(u(z0, z1, z2, z3), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__u(mark(z0), z1, z2, z3), x3)), x0, x1, cons(u(z0, z1, z2, z3), x3)), A__SPLITAT(mark(x0), mark(cons(u(z0, z1, z2, z3), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(head(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__head(mark(z0)), x3)), x0, x1, cons(head(z0), x3)), A__SPLITAT(mark(x0), mark(cons(head(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(tail(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__tail(mark(z0)), x3)), x0, x1, cons(tail(z0), x3)), A__SPLITAT(mark(x0), mark(cons(tail(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(sel(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__sel(mark(z0), mark(z1)), x3)), x0, x1, cons(sel(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(sel(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(afterNth(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__afterNth(mark(z0), mark(z1)), x3)), x0, x1, cons(afterNth(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(afterNth(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(take(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(a__take(mark(z0), mark(z1)), x3)), x0, x1, cons(take(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(take(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(cons(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(cons(mark(z0), z1), x3)), x0, x1, cons(cons(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(cons(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(s(z0), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(s(mark(z0)), x3)), x0, x1, cons(s(z0), x3)), A__SPLITAT(mark(x0), mark(cons(s(z0), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(pair(z0, z1), x3))) -> c7(A__U(a__splitAt(mark(x0), cons(pair(mark(z0), mark(z1)), x3)), x0, x1, cons(pair(z0, z1), x3)), A__SPLITAT(mark(x0), mark(cons(pair(z0, z1), x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(0, x3))) -> c7(A__U(a__splitAt(mark(x0), cons(0, x3)), x0, x1, cons(0, x3)), A__SPLITAT(mark(x0), mark(cons(0, x3))), MARK(x0))
   A__SPLITAT(s(x0), cons(x1, cons(nil, x3))) -> c7(A__U(a__splitAt(mark(x0), cons(nil, x3)), x0, x1, cons(nil, x3)), A__SPLITAT(mark(x0), mark(cons(nil, x3))), MARK(x0))
   A__SPLITAT(s(natsFrom(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__natsFrom(mark(z0)), cons(mark(x2), x3)), natsFrom(z0), x1, cons(x2, x3)), A__SPLITAT(mark(natsFrom(z0)), mark(cons(x2, x3))), MARK(natsFrom(z0)))
   A__SPLITAT(s(fst(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__fst(mark(z0)), cons(mark(x2), x3)), fst(z0), x1, cons(x2, x3)), A__SPLITAT(mark(fst(z0)), mark(cons(x2, x3))), MARK(fst(z0)))
   A__SPLITAT(s(snd(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__snd(mark(z0)), cons(mark(x2), x3)), snd(z0), x1, cons(x2, x3)), A__SPLITAT(mark(snd(z0)), mark(cons(x2, x3))), MARK(snd(z0)))
   A__SPLITAT(s(splitAt(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__splitAt(mark(z0), mark(z1)), cons(mark(x2), x3)), splitAt(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(splitAt(z0, z1)), mark(cons(x2, x3))), MARK(splitAt(z0, z1)))
   A__SPLITAT(s(u(z0, z1, z2, z3)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__u(mark(z0), z1, z2, z3), cons(mark(x2), x3)), u(z0, z1, z2, z3), x1, cons(x2, x3)), A__SPLITAT(mark(u(z0, z1, z2, z3)), mark(cons(x2, x3))), MARK(u(z0, z1, z2, z3)))
   A__SPLITAT(s(head(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__head(mark(z0)), cons(mark(x2), x3)), head(z0), x1, cons(x2, x3)), A__SPLITAT(mark(head(z0)), mark(cons(x2, x3))), MARK(head(z0)))
   A__SPLITAT(s(tail(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__tail(mark(z0)), cons(mark(x2), x3)), tail(z0), x1, cons(x2, x3)), A__SPLITAT(mark(tail(z0)), mark(cons(x2, x3))), MARK(tail(z0)))
   A__SPLITAT(s(sel(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__sel(mark(z0), mark(z1)), cons(mark(x2), x3)), sel(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(sel(z0, z1)), mark(cons(x2, x3))), MARK(sel(z0, z1)))
   A__SPLITAT(s(afterNth(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__afterNth(mark(z0), mark(z1)), cons(mark(x2), x3)), afterNth(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(afterNth(z0, z1)), mark(cons(x2, x3))), MARK(afterNth(z0, z1)))
   A__SPLITAT(s(take(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(a__take(mark(z0), mark(z1)), cons(mark(x2), x3)), take(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(take(z0, z1)), mark(cons(x2, x3))), MARK(take(z0, z1)))
   A__SPLITAT(s(cons(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(cons(mark(z0), z1), cons(mark(x2), x3)), cons(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(cons(z0, z1)), mark(cons(x2, x3))), MARK(cons(z0, z1)))
   A__SPLITAT(s(s(z0)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(s(mark(z0)), cons(mark(x2), x3)), s(z0), x1, cons(x2, x3)), A__SPLITAT(mark(s(z0)), mark(cons(x2, x3))), MARK(s(z0)))
   A__SPLITAT(s(pair(z0, z1)), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(pair(mark(z0), mark(z1)), cons(mark(x2), x3)), pair(z0, z1), x1, cons(x2, x3)), A__SPLITAT(mark(pair(z0, z1)), mark(cons(x2, x3))), MARK(pair(z0, z1)))
   A__SPLITAT(s(x0), cons(x1, cons(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(cons(x2, x3))))
   A__SPLITAT(s(x0), cons(x1, cons(x2, x3))) -> c7(A__SPLITAT(mark(x0), mark(cons(x2, x3))), MARK(x0))
   A__SPLITAT(s(0), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(0, cons(mark(x2), x3)), 0, x1, cons(x2, x3)), A__SPLITAT(mark(0), mark(cons(x2, x3))))
   A__SPLITAT(s(nil), cons(x1, cons(x2, x3))) -> c7(A__U(a__splitAt(nil, cons(mark(x2), x3)), nil, x1, cons(x2, x3)), A__SPLITAT(mark(nil), mark(cons(x2, x3))))
K tuples:none
Defined Rule Symbols:   a__natsFrom_1, a__fst_1, a__snd_1, a__splitAt_2, a__u_4, a__head_1, a__tail_1, a__sel_2, a__take_2, a__afterNth_2, mark_1

Defined Pair Symbols:   A__NATSFROM_1, A__FST_1, A__SND_1, A__SPLITAT_2, A__U_4, A__HEAD_1, A__TAIL_1, MARK_1, A__SEL_2, A__TAKE_2, A__AFTERNTH_2

Compound Symbols:   c_1, c2_1, c4_1, c6_1, c10_1, c11_1, c13_1, c15_1, c26_2, c34_2, c35_2, c36_2, c37_2, c38_2, c39_2, c40_1, c41_1, c42_1, c43_1, c7_3, c7_2, c8_3, c8_2, c17_3, c17_2, c18_3, c18_2, c20_3, c20_2, c21_3, c21_2, c23_3, c23_2, c24_3, c24_2, c27_2, c27_1, c28_2, c28_1, c29_2, c29_1, c30_2, c30_1, c31_2, c31_1, c32_2, c32_1, c33_2, c33_1, c7_1