KILLED
proof of input_HtR9VXv484.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) RelTrsToWeightedTrsProof [UPPER BOUND(ID), 0 ms]
(6) CpxWeightedTrs
    (7) TypeInferenceProof [BOTH BOUNDS(ID, ID), 0 ms]
    (8) CpxTypedWeightedTrs
    (9) CompletionProof [UPPER BOUND(ID), 0 ms]
    (10) CpxTypedWeightedCompleteTrs
        (11) NarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
        (12) CpxTypedWeightedCompleteTrs
        (13) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (14) CpxRNTS
        (15) InliningProof [UPPER BOUND(ID), 380 ms]
        (16) CpxRNTS
        (17) SimplificationProof [BOTH BOUNDS(ID, ID), 0 ms]
        (18) CpxRNTS
        (19) CpxRntsAnalysisOrderProof [BOTH BOUNDS(ID, ID), 1 ms]
        (20) CpxRNTS
        (21) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (22) CpxRNTS
        (23) IntTrsBoundProof [UPPER BOUND(ID), 109 ms]
        (24) CpxRNTS
        (25) IntTrsBoundProof [UPPER BOUND(ID), 0 ms]
        (26) CpxRNTS
        (27) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (28) CpxRNTS
        (29) IntTrsBoundProof [UPPER BOUND(ID), 185 ms]
        (30) CpxRNTS
        (31) IntTrsBoundProof [UPPER BOUND(ID), 53 ms]
        (32) CpxRNTS
        (33) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (34) CpxRNTS
        (35) IntTrsBoundProof [UPPER BOUND(ID), 152 ms]
        (36) CpxRNTS
        (37) IntTrsBoundProof [UPPER BOUND(ID), 0 ms]
        (38) CpxRNTS
        (39) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (40) CpxRNTS
        (41) IntTrsBoundProof [UPPER BOUND(ID), 59 ms]
        (42) CpxRNTS
        (43) IntTrsBoundProof [UPPER BOUND(ID), 3 ms]
        (44) CpxRNTS
        (45) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (46) CpxRNTS
        (47) IntTrsBoundProof [UPPER BOUND(ID), 3035 ms]
        (48) CpxRNTS
        (49) IntTrsBoundProof [UPPER BOUND(ID), 249 ms]
        (50) CpxRNTS
        (51) ResultPropagationProof [UPPER BOUND(ID), 0 ms]
        (52) CpxRNTS
        (53) IntTrsBoundProof [UPPER BOUND(ID), 3259 ms]
        (54) CpxRNTS
        (55) IntTrsBoundProof [UPPER BOUND(ID), 423 ms]
        (56) CpxRNTS
    (57) CompletionProof [UPPER BOUND(ID), 0 ms]
    (58) CpxTypedWeightedCompleteTrs
        (59) CpxTypedWeightedTrsToRntsProof [UPPER BOUND(ID), 0 ms]
        (60) CpxRNTS
(61) CpxTrsToCdtProof [UPPER BOUND(ID), 0 ms]
(62) CdtProblem
    (63) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (64) CdtProblem
    (65) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (66) CdtProblem
    (67) CdtUsableRulesProof [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), 0 ms]
    (74) CdtProblem
    (75) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (76) CdtProblem
    (77) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (78) CdtProblem
    (79) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (80) CdtProblem
    (81) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 41 ms]
    (82) CdtProblem
    (83) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (84) CdtProblem
    (85) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (86) CdtProblem
    (87) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 46 ms]
    (88) CdtProblem
    (89) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (90) CdtProblem
    (91) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (92) CdtProblem
    (93) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (94) CdtProblem
    (95) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (96) CdtProblem
    (97) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (98) CdtProblem
    (99) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (100) CdtProblem
    (101) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (102) CdtProblem
    (103) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 20 ms]
    (104) CdtProblem
    (105) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (106) CdtProblem
    (107) CdtKnowledgeProof [BOTH BOUNDS(ID, ID), 0 ms]
    (108) CdtProblem
    (109) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (110) CdtProblem
    (111) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (112) CdtProblem
    (113) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (114) CdtProblem
    (115) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 79 ms]
    (116) CdtProblem
    (117) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (118) CdtProblem
    (119) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (120) CdtProblem
    (121) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (122) CdtProblem
    (123) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (124) CdtProblem
    (125) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (126) CdtProblem
    (127) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (128) CdtProblem
    (129) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (130) CdtProblem
    (131) CdtRewritingProof [BOTH BOUNDS(ID, ID), 8 ms]
    (132) CdtProblem
    (133) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (134) CdtProblem
    (135) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (136) CdtProblem
    (137) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (138) CdtProblem
    (139) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 136 ms]
    (140) CdtProblem
    (141) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 104 ms]
    (142) CdtProblem
    (143) CdtRewritingProof [BOTH BOUNDS(ID, ID), 5 ms]
    (144) CdtProblem
    (145) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (146) CdtProblem
    (147) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (148) CdtProblem
    (149) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (150) CdtProblem
    (151) CdtNarrowingProof [BOTH BOUNDS(ID, ID), 189 ms]
    (152) CdtProblem
    (153) CdtRewritingProof [BOTH BOUNDS(ID, ID), 0 ms]
    (154) CdtProblem
    (155) CdtRewritingProof [BOTH BOUNDS(ID, ID), 12 ms]
    (156) CdtProblem
    (157) CdtRewritingProof [BOTH BOUNDS(ID, ID), 10 ms]
    (158) CdtProblem
    (159) CdtRewritingProof [BOTH BOUNDS(ID, ID), 20 ms]
    (160) CdtProblem
    (161) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 42 ms]
    (162) CdtProblem
    (163) CdtRhsSimplificationProcessorProof [BOTH BOUNDS(ID, ID), 0 ms]
    (164) CdtProblem
    (165) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 177 ms]
    (166) CdtProblem
    (167) CdtRuleRemovalProof [UPPER BOUND(ADD(n^1)), 204 ms]
    (168) CdtProblem
    (169) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (170) CdtProblem
    (171) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 4 ms]
    (172) CdtProblem
    (173) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 5 ms]
    (174) CdtProblem
    (175) CdtLeafRemovalProof [BOTH BOUNDS(ID, ID), 0 ms]
    (176) CdtProblem
    (177) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (178) CdtProblem
    (179) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (180) CdtProblem
    (181) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (182) CdtProblem
    (183) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (184) CdtProblem
    (185) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 14 ms]
    (186) CdtProblem
    (187) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (188) CdtProblem
    (189) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (190) CdtProblem
    (191) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (192) CdtProblem
    (193) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (194) CdtProblem
    (195) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (196) CdtProblem
    (197) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (198) CdtProblem
    (199) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (200) CdtProblem
    (201) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (202) CdtProblem
    (203) CdtForwardInstantiationProof [BOTH BOUNDS(ID, ID), 0 ms]
    (204) 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:

   from(X) -> cons(X, n__from(n__s(X)))
   length(n__nil) -> 0
   length(n__cons(X, Y)) -> s(length1(activate(Y)))
   length1(X) -> length(activate(X))
   from(X) -> n__from(X)
   s(X) -> n__s(X)
   nil -> n__nil
   cons(X1, X2) -> n__cons(X1, X2)
   activate(n__from(X)) -> from(activate(X))
   activate(n__s(X)) -> s(activate(X))
   activate(n__nil) -> nil
   activate(n__cons(X1, X2)) -> cons(activate(X1), X2)
   activate(X) -> X

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:

   from(X) -> cons(X, n__from(n__s(X)))
   length(n__nil) -> 0'
   length(n__cons(X, Y)) -> s(length1(activate(Y)))
   length1(X) -> length(activate(X))
   from(X) -> n__from(X)
   s(X) -> n__s(X)
   nil -> n__nil
   cons(X1, X2) -> n__cons(X1, X2)
   activate(n__from(X)) -> from(activate(X))
   activate(n__s(X)) -> s(activate(X))
   activate(n__nil) -> nil
   activate(n__cons(X1, X2)) -> cons(activate(X1), X2)
   activate(X) -> X

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:

   from(X) -> cons(X, n__from(n__s(X)))
   length(n__nil) -> 0
   length(n__cons(X, Y)) -> s(length1(activate(Y)))
   length1(X) -> length(activate(X))
   from(X) -> n__from(X)
   s(X) -> n__s(X)
   nil -> n__nil
   cons(X1, X2) -> n__cons(X1, X2)
   activate(n__from(X)) -> from(activate(X))
   activate(n__s(X)) -> s(activate(X))
   activate(n__nil) -> nil
   activate(n__cons(X1, X2)) -> cons(activate(X1), X2)
   activate(X) -> X

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

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

(6)
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:

   from(X) -> cons(X, n__from(n__s(X))) [1]
   length(n__nil) -> 0 [1]
   length(n__cons(X, Y)) -> s(length1(activate(Y))) [1]
   length1(X) -> length(activate(X)) [1]
   from(X) -> n__from(X) [1]
   s(X) -> n__s(X) [1]
   nil -> n__nil [1]
   cons(X1, X2) -> n__cons(X1, X2) [1]
   activate(n__from(X)) -> from(activate(X)) [1]
   activate(n__s(X)) -> s(activate(X)) [1]
   activate(n__nil) -> nil [1]
   activate(n__cons(X1, X2)) -> cons(activate(X1), X2) [1]
   activate(X) -> X [1]

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

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

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

   from(X) -> cons(X, n__from(n__s(X))) [1]
   length(n__nil) -> 0 [1]
   length(n__cons(X, Y)) -> s(length1(activate(Y))) [1]
   length1(X) -> length(activate(X)) [1]
   from(X) -> n__from(X) [1]
   s(X) -> n__s(X) [1]
   nil -> n__nil [1]
   cons(X1, X2) -> n__cons(X1, X2) [1]
   activate(n__from(X)) -> from(activate(X)) [1]
   activate(n__s(X)) -> s(activate(X)) [1]
   activate(n__nil) -> nil [1]
   activate(n__cons(X1, X2)) -> cons(activate(X1), X2) [1]
   activate(X) -> X [1]

The TRS has the following type information:
from :: n__s:n__from:n__nil:0:n__cons -> n__s:n__from:n__nil:0:n__cons
cons :: n__s:n__from:n__nil:0:n__cons -> n__s:n__from:n__nil:0:n__cons -> n__s:n__from:n__nil:0:n__cons
n__from :: n__s:n__from:n__nil:0:n__cons -> n__s:n__from:n__nil:0:n__cons
n__s :: n__s:n__from:n__nil:0:n__cons -> n__s:n__from:n__nil:0:n__cons
length :: n__s:n__from:n__nil:0:n__cons -> n__s:n__from:n__nil:0:n__cons
n__nil :: n__s:n__from:n__nil:0:n__cons
0 :: n__s:n__from:n__nil:0:n__cons
n__cons :: n__s:n__from:n__nil:0:n__cons -> n__s:n__from:n__nil:0:n__cons -> n__s:n__from:n__nil:0:n__cons
s :: n__s:n__from:n__nil:0:n__cons -> n__s:n__from:n__nil:0:n__cons
length1 :: n__s:n__from:n__nil:0:n__cons -> n__s:n__from:n__nil:0:n__cons
activate :: n__s:n__from:n__nil:0:n__cons -> n__s:n__from:n__nil:0:n__cons
nil :: n__s:n__from:n__nil:0:n__cons

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

(9) 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:

   activate_1
   length1_1
   length_1
   s_1
   from_1
   cons_2
   nil

Due to the following rules being added:

   length(v0) -> null_length [0]

And the following fresh constants:    null_length

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

(10)
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:

   from(X) -> cons(X, n__from(n__s(X))) [1]
   length(n__nil) -> 0 [1]
   length(n__cons(X, Y)) -> s(length1(activate(Y))) [1]
   length1(X) -> length(activate(X)) [1]
   from(X) -> n__from(X) [1]
   s(X) -> n__s(X) [1]
   nil -> n__nil [1]
   cons(X1, X2) -> n__cons(X1, X2) [1]
   activate(n__from(X)) -> from(activate(X)) [1]
   activate(n__s(X)) -> s(activate(X)) [1]
   activate(n__nil) -> nil [1]
   activate(n__cons(X1, X2)) -> cons(activate(X1), X2) [1]
   activate(X) -> X [1]
   length(v0) -> null_length [0]

The TRS has the following type information:
from :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
cons :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
n__from :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
n__s :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
length :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
n__nil :: n__s:n__from:n__nil:0:n__cons:null_length
0 :: n__s:n__from:n__nil:0:n__cons:null_length
n__cons :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
s :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
length1 :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
activate :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
nil :: n__s:n__from:n__nil:0:n__cons:null_length
null_length :: n__s:n__from:n__nil:0:n__cons:null_length

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

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

(12)
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:

   from(X) -> cons(X, n__from(n__s(X))) [1]
   length(n__nil) -> 0 [1]
   length(n__cons(X, n__from(X'))) -> s(length1(from(activate(X')))) [2]
   length(n__cons(X, n__s(X''))) -> s(length1(s(activate(X'')))) [2]
   length(n__cons(X, n__nil)) -> s(length1(nil)) [2]
   length(n__cons(X, n__cons(X1', X2'))) -> s(length1(cons(activate(X1'), X2'))) [2]
   length(n__cons(X, Y)) -> s(length1(Y)) [2]
   length1(n__from(X3)) -> length(from(activate(X3))) [2]
   length1(n__s(X4)) -> length(s(activate(X4))) [2]
   length1(n__nil) -> length(nil) [2]
   length1(n__cons(X1'', X2'')) -> length(cons(activate(X1''), X2'')) [2]
   length1(X) -> length(X) [2]
   from(X) -> n__from(X) [1]
   s(X) -> n__s(X) [1]
   nil -> n__nil [1]
   cons(X1, X2) -> n__cons(X1, X2) [1]
   activate(n__from(n__from(X5))) -> from(from(activate(X5))) [2]
   activate(n__from(n__s(X6))) -> from(s(activate(X6))) [2]
   activate(n__from(n__nil)) -> from(nil) [2]
   activate(n__from(n__cons(X11, X21))) -> from(cons(activate(X11), X21)) [2]
   activate(n__from(X)) -> from(X) [2]
   activate(n__s(n__from(X7))) -> s(from(activate(X7))) [2]
   activate(n__s(n__s(X8))) -> s(s(activate(X8))) [2]
   activate(n__s(n__nil)) -> s(nil) [2]
   activate(n__s(n__cons(X12, X22))) -> s(cons(activate(X12), X22)) [2]
   activate(n__s(X)) -> s(X) [2]
   activate(n__nil) -> nil [1]
   activate(n__cons(n__from(X9), X2)) -> cons(from(activate(X9)), X2) [2]
   activate(n__cons(n__s(X10), X2)) -> cons(s(activate(X10)), X2) [2]
   activate(n__cons(n__nil, X2)) -> cons(nil, X2) [2]
   activate(n__cons(n__cons(X13, X23), X2)) -> cons(cons(activate(X13), X23), X2) [2]
   activate(n__cons(X1, X2)) -> cons(X1, X2) [2]
   activate(X) -> X [1]
   length(v0) -> null_length [0]

The TRS has the following type information:
from :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
cons :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
n__from :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
n__s :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
length :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
n__nil :: n__s:n__from:n__nil:0:n__cons:null_length
0 :: n__s:n__from:n__nil:0:n__cons:null_length
n__cons :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
s :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
length1 :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
activate :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
nil :: n__s:n__from:n__nil:0:n__cons:null_length
null_length :: n__s:n__from:n__nil:0:n__cons:null_length

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

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

   n__nil => 1
   0 => 0
   null_length => 0

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

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

   activate(z) -{ 1 }-> X :|: X >= 0, z = X
   activate(z) -{ 2 }-> s(X) :|: z = 1 + X, X >= 0
   activate(z) -{ 2 }-> s(s(activate(X8))) :|: X8 >= 0, z = 1 + (1 + X8)
   activate(z) -{ 2 }-> s(nil) :|: z = 1 + 1
   activate(z) -{ 2 }-> s(from(activate(X7))) :|: X7 >= 0, z = 1 + (1 + X7)
   activate(z) -{ 2 }-> s(cons(activate(X12), X22)) :|: X12 >= 0, X22 >= 0, z = 1 + (1 + X12 + X22)
   activate(z) -{ 1 }-> nil :|: z = 1
   activate(z) -{ 2 }-> from(X) :|: z = 1 + X, X >= 0
   activate(z) -{ 2 }-> from(s(activate(X6))) :|: X6 >= 0, z = 1 + (1 + X6)
   activate(z) -{ 2 }-> from(nil) :|: z = 1 + 1
   activate(z) -{ 2 }-> from(from(activate(X5))) :|: X5 >= 0, z = 1 + (1 + X5)
   activate(z) -{ 2 }-> from(cons(activate(X11), X21)) :|: z = 1 + (1 + X11 + X21), X11 >= 0, X21 >= 0
   activate(z) -{ 2 }-> cons(X1, X2) :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2
   activate(z) -{ 2 }-> cons(s(activate(X10)), X2) :|: X10 >= 0, z = 1 + (1 + X10) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(nil, X2) :|: z = 1 + 1 + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(from(activate(X9)), X2) :|: X9 >= 0, z = 1 + (1 + X9) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(cons(activate(X13), X23), X2) :|: z = 1 + (1 + X13 + X23) + X2, X2 >= 0, X13 >= 0, X23 >= 0
   cons(z, z') -{ 1 }-> 1 + X1 + X2 :|: X1 >= 0, X2 >= 0, z = X1, z' = X2
   from(z) -{ 1 }-> cons(X, 1 + (1 + X)) :|: X >= 0, z = X
   from(z) -{ 1 }-> 1 + X :|: X >= 0, z = X
   length(z) -{ 2 }-> s(length1(Y)) :|: Y >= 0, z = 1 + X + Y, X >= 0
   length(z) -{ 2 }-> s(length1(s(activate(X'')))) :|: z = 1 + X + (1 + X''), X >= 0, X'' >= 0
   length(z) -{ 2 }-> s(length1(nil)) :|: z = 1 + X + 1, X >= 0
   length(z) -{ 2 }-> s(length1(from(activate(X')))) :|: z = 1 + X + (1 + X'), X >= 0, X' >= 0
   length(z) -{ 2 }-> s(length1(cons(activate(X1'), X2'))) :|: X2' >= 0, X1' >= 0, X >= 0, z = 1 + X + (1 + X1' + X2')
   length(z) -{ 1 }-> 0 :|: z = 1
   length(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   length1(z) -{ 2 }-> length(X) :|: X >= 0, z = X
   length1(z) -{ 2 }-> length(s(activate(X4))) :|: z = 1 + X4, X4 >= 0
   length1(z) -{ 2 }-> length(nil) :|: z = 1
   length1(z) -{ 2 }-> length(from(activate(X3))) :|: z = 1 + X3, X3 >= 0
   length1(z) -{ 2 }-> length(cons(activate(X1''), X2'')) :|: X1'' >= 0, z = 1 + X1'' + X2'', X2'' >= 0
   nil -{ 1 }-> 1 :|: 
   s(z) -{ 1 }-> 1 + X :|: X >= 0, z = X


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

(15) InliningProof (UPPER BOUND(ID))
Inlined the following terminating rules on right-hand sides where appropriate:

   s(z) -{ 1 }-> 1 + X :|: X >= 0, z = X
   nil -{ 1 }-> 1 :|: 
   cons(z, z') -{ 1 }-> 1 + X1 + X2 :|: X1 >= 0, X2 >= 0, z = X1, z' = X2
   from(z) -{ 1 }-> cons(X, 1 + (1 + X)) :|: X >= 0, z = X
   from(z) -{ 1 }-> 1 + X :|: X >= 0, z = X

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

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

   activate(z) -{ 1 }-> X :|: X >= 0, z = X
   activate(z) -{ 2 }-> s(s(activate(X8))) :|: X8 >= 0, z = 1 + (1 + X8)
   activate(z) -{ 2 }-> s(from(activate(X7))) :|: X7 >= 0, z = 1 + (1 + X7)
   activate(z) -{ 2 }-> s(cons(activate(X12), X22)) :|: X12 >= 0, X22 >= 0, z = 1 + (1 + X12 + X22)
   activate(z) -{ 3 }-> s(1) :|: z = 1 + 1
   activate(z) -{ 2 }-> from(s(activate(X6))) :|: X6 >= 0, z = 1 + (1 + X6)
   activate(z) -{ 2 }-> from(from(activate(X5))) :|: X5 >= 0, z = 1 + (1 + X5)
   activate(z) -{ 2 }-> from(cons(activate(X11), X21)) :|: z = 1 + (1 + X11 + X21), X11 >= 0, X21 >= 0
   activate(z) -{ 4 }-> cons(X, 1 + (1 + X)) :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> cons(X', 1 + (1 + X')) :|: z = 1 + X, X >= 0, X' >= 0, X = X'
   activate(z) -{ 2 }-> cons(s(activate(X10)), X2) :|: X10 >= 0, z = 1 + (1 + X10) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(from(activate(X9)), X2) :|: X9 >= 0, z = 1 + (1 + X9) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(cons(activate(X13), X23), X2) :|: z = 1 + (1 + X13 + X23) + X2, X2 >= 0, X13 >= 0, X23 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z = 1 + X, X >= 0, X' >= 0, X = X'
   activate(z) -{ 4 }-> 1 + X1 + X2' :|: z = 1 + 1 + X2, X2 >= 0, X1 >= 0, X2' >= 0, 1 = X1, X2 = X2'
   activate(z) -{ 3 }-> 1 + X1' + X2' :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2, X1' >= 0, X2' >= 0, X1 = X1', X2 = X2'
   cons(z, z') -{ 1 }-> 1 + X1 + X2 :|: X1 >= 0, X2 >= 0, z = X1, z' = X2
   from(z) -{ 1 }-> 1 + X :|: X >= 0, z = X
   from(z) -{ 2 }-> 1 + X1 + X2 :|: X >= 0, z = X, X1 >= 0, X2 >= 0, X = X1, 1 + (1 + X) = X2
   length(z) -{ 2 }-> s(length1(Y)) :|: Y >= 0, z = 1 + X + Y, X >= 0
   length(z) -{ 2 }-> s(length1(s(activate(X'')))) :|: z = 1 + X + (1 + X''), X >= 0, X'' >= 0
   length(z) -{ 2 }-> s(length1(from(activate(X')))) :|: z = 1 + X + (1 + X'), X >= 0, X' >= 0
   length(z) -{ 2 }-> s(length1(cons(activate(X1'), X2'))) :|: X2' >= 0, X1' >= 0, X >= 0, z = 1 + X + (1 + X1' + X2')
   length(z) -{ 3 }-> s(length1(1)) :|: z = 1 + X + 1, X >= 0
   length(z) -{ 1 }-> 0 :|: z = 1
   length(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   length1(z) -{ 2 }-> length(X) :|: X >= 0, z = X
   length1(z) -{ 2 }-> length(s(activate(X4))) :|: z = 1 + X4, X4 >= 0
   length1(z) -{ 2 }-> length(from(activate(X3))) :|: z = 1 + X3, X3 >= 0
   length1(z) -{ 2 }-> length(cons(activate(X1''), X2'')) :|: X1'' >= 0, z = 1 + X1'' + X2'', X2'' >= 0
   length1(z) -{ 3 }-> length(1) :|: z = 1
   nil -{ 1 }-> 1 :|: 
   s(z) -{ 1 }-> 1 + X :|: X >= 0, z = X


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

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> s(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(cons(activate(X12), X22)) :|: X12 >= 0, X22 >= 0, z = 1 + (1 + X12 + X22)
   activate(z) -{ 3 }-> s(1) :|: z = 1 + 1
   activate(z) -{ 2 }-> from(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(cons(activate(X11), X21)) :|: z = 1 + (1 + X11 + X21), X11 >= 0, X21 >= 0
   activate(z) -{ 4 }-> cons(X, 1 + (1 + X)) :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> cons(X', 1 + (1 + X')) :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> cons(s(activate(X10)), X2) :|: X10 >= 0, z = 1 + (1 + X10) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(from(activate(X9)), X2) :|: X9 >= 0, z = 1 + (1 + X9) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(cons(activate(X13), X23), X2) :|: z = 1 + (1 + X13 + X23) + X2, X2 >= 0, X13 >= 0, X23 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 4 }-> 1 + X1 + X2' :|: z - 2 >= 0, X1 >= 0, X2' >= 0, 1 = X1, z - 2 = X2'
   activate(z) -{ 3 }-> 1 + X1' + X2' :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2, X1' >= 0, X2' >= 0, X1 = X1', X2 = X2'
   cons(z, z') -{ 1 }-> 1 + z + z' :|: z >= 0, z' >= 0
   from(z) -{ 1 }-> 1 + z :|: z >= 0
   from(z) -{ 2 }-> 1 + z + X2 :|: z >= 0, X2 >= 0, 1 + (1 + z) = X2
   length(z) -{ 2 }-> s(length1(Y)) :|: Y >= 0, z = 1 + X + Y, X >= 0
   length(z) -{ 2 }-> s(length1(s(activate(X'')))) :|: z = 1 + X + (1 + X''), X >= 0, X'' >= 0
   length(z) -{ 2 }-> s(length1(from(activate(X')))) :|: z = 1 + X + (1 + X'), X >= 0, X' >= 0
   length(z) -{ 2 }-> s(length1(cons(activate(X1'), X2'))) :|: X2' >= 0, X1' >= 0, X >= 0, z = 1 + X + (1 + X1' + X2')
   length(z) -{ 3 }-> s(length1(1)) :|: z - 2 >= 0
   length(z) -{ 1 }-> 0 :|: z = 1
   length(z) -{ 0 }-> 0 :|: z >= 0
   length1(z) -{ 2 }-> length(z) :|: z >= 0
   length1(z) -{ 2 }-> length(s(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(from(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(cons(activate(X1''), X2'')) :|: X1'' >= 0, z = 1 + X1'' + X2'', X2'' >= 0
   length1(z) -{ 3 }-> length(1) :|: z = 1
   nil -{ 1 }-> 1 :|: 
   s(z) -{ 1 }-> 1 + z :|: z >= 0


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

(19) CpxRntsAnalysisOrderProof (BOTH BOUNDS(ID, ID))
Found the following analysis order by SCC decomposition:

   { nil }
   { from }
   { cons }
   { s }
   { activate }
   { length1, length }

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> s(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(cons(activate(X12), X22)) :|: X12 >= 0, X22 >= 0, z = 1 + (1 + X12 + X22)
   activate(z) -{ 3 }-> s(1) :|: z = 1 + 1
   activate(z) -{ 2 }-> from(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(cons(activate(X11), X21)) :|: z = 1 + (1 + X11 + X21), X11 >= 0, X21 >= 0
   activate(z) -{ 4 }-> cons(X, 1 + (1 + X)) :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> cons(X', 1 + (1 + X')) :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> cons(s(activate(X10)), X2) :|: X10 >= 0, z = 1 + (1 + X10) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(from(activate(X9)), X2) :|: X9 >= 0, z = 1 + (1 + X9) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(cons(activate(X13), X23), X2) :|: z = 1 + (1 + X13 + X23) + X2, X2 >= 0, X13 >= 0, X23 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 4 }-> 1 + X1 + X2' :|: z - 2 >= 0, X1 >= 0, X2' >= 0, 1 = X1, z - 2 = X2'
   activate(z) -{ 3 }-> 1 + X1' + X2' :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2, X1' >= 0, X2' >= 0, X1 = X1', X2 = X2'
   cons(z, z') -{ 1 }-> 1 + z + z' :|: z >= 0, z' >= 0
   from(z) -{ 1 }-> 1 + z :|: z >= 0
   from(z) -{ 2 }-> 1 + z + X2 :|: z >= 0, X2 >= 0, 1 + (1 + z) = X2
   length(z) -{ 2 }-> s(length1(Y)) :|: Y >= 0, z = 1 + X + Y, X >= 0
   length(z) -{ 2 }-> s(length1(s(activate(X'')))) :|: z = 1 + X + (1 + X''), X >= 0, X'' >= 0
   length(z) -{ 2 }-> s(length1(from(activate(X')))) :|: z = 1 + X + (1 + X'), X >= 0, X' >= 0
   length(z) -{ 2 }-> s(length1(cons(activate(X1'), X2'))) :|: X2' >= 0, X1' >= 0, X >= 0, z = 1 + X + (1 + X1' + X2')
   length(z) -{ 3 }-> s(length1(1)) :|: z - 2 >= 0
   length(z) -{ 1 }-> 0 :|: z = 1
   length(z) -{ 0 }-> 0 :|: z >= 0
   length1(z) -{ 2 }-> length(z) :|: z >= 0
   length1(z) -{ 2 }-> length(s(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(from(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(cons(activate(X1''), X2'')) :|: X1'' >= 0, z = 1 + X1'' + X2'', X2'' >= 0
   length1(z) -{ 3 }-> length(1) :|: z = 1
   nil -{ 1 }-> 1 :|: 
   s(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {nil}, {from}, {cons}, {s}, {activate}, {length1,length}

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

(21) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> s(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(cons(activate(X12), X22)) :|: X12 >= 0, X22 >= 0, z = 1 + (1 + X12 + X22)
   activate(z) -{ 3 }-> s(1) :|: z = 1 + 1
   activate(z) -{ 2 }-> from(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(cons(activate(X11), X21)) :|: z = 1 + (1 + X11 + X21), X11 >= 0, X21 >= 0
   activate(z) -{ 4 }-> cons(X, 1 + (1 + X)) :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> cons(X', 1 + (1 + X')) :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> cons(s(activate(X10)), X2) :|: X10 >= 0, z = 1 + (1 + X10) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(from(activate(X9)), X2) :|: X9 >= 0, z = 1 + (1 + X9) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(cons(activate(X13), X23), X2) :|: z = 1 + (1 + X13 + X23) + X2, X2 >= 0, X13 >= 0, X23 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 4 }-> 1 + X1 + X2' :|: z - 2 >= 0, X1 >= 0, X2' >= 0, 1 = X1, z - 2 = X2'
   activate(z) -{ 3 }-> 1 + X1' + X2' :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2, X1' >= 0, X2' >= 0, X1 = X1', X2 = X2'
   cons(z, z') -{ 1 }-> 1 + z + z' :|: z >= 0, z' >= 0
   from(z) -{ 1 }-> 1 + z :|: z >= 0
   from(z) -{ 2 }-> 1 + z + X2 :|: z >= 0, X2 >= 0, 1 + (1 + z) = X2
   length(z) -{ 2 }-> s(length1(Y)) :|: Y >= 0, z = 1 + X + Y, X >= 0
   length(z) -{ 2 }-> s(length1(s(activate(X'')))) :|: z = 1 + X + (1 + X''), X >= 0, X'' >= 0
   length(z) -{ 2 }-> s(length1(from(activate(X')))) :|: z = 1 + X + (1 + X'), X >= 0, X' >= 0
   length(z) -{ 2 }-> s(length1(cons(activate(X1'), X2'))) :|: X2' >= 0, X1' >= 0, X >= 0, z = 1 + X + (1 + X1' + X2')
   length(z) -{ 3 }-> s(length1(1)) :|: z - 2 >= 0
   length(z) -{ 1 }-> 0 :|: z = 1
   length(z) -{ 0 }-> 0 :|: z >= 0
   length1(z) -{ 2 }-> length(z) :|: z >= 0
   length1(z) -{ 2 }-> length(s(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(from(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(cons(activate(X1''), X2'')) :|: X1'' >= 0, z = 1 + X1'' + X2'', X2'' >= 0
   length1(z) -{ 3 }-> length(1) :|: z = 1
   nil -{ 1 }-> 1 :|: 
   s(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {nil}, {from}, {cons}, {s}, {activate}, {length1,length}

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

(23) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: nil
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 1

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> s(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(cons(activate(X12), X22)) :|: X12 >= 0, X22 >= 0, z = 1 + (1 + X12 + X22)
   activate(z) -{ 3 }-> s(1) :|: z = 1 + 1
   activate(z) -{ 2 }-> from(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(cons(activate(X11), X21)) :|: z = 1 + (1 + X11 + X21), X11 >= 0, X21 >= 0
   activate(z) -{ 4 }-> cons(X, 1 + (1 + X)) :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> cons(X', 1 + (1 + X')) :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> cons(s(activate(X10)), X2) :|: X10 >= 0, z = 1 + (1 + X10) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(from(activate(X9)), X2) :|: X9 >= 0, z = 1 + (1 + X9) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(cons(activate(X13), X23), X2) :|: z = 1 + (1 + X13 + X23) + X2, X2 >= 0, X13 >= 0, X23 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 4 }-> 1 + X1 + X2' :|: z - 2 >= 0, X1 >= 0, X2' >= 0, 1 = X1, z - 2 = X2'
   activate(z) -{ 3 }-> 1 + X1' + X2' :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2, X1' >= 0, X2' >= 0, X1 = X1', X2 = X2'
   cons(z, z') -{ 1 }-> 1 + z + z' :|: z >= 0, z' >= 0
   from(z) -{ 1 }-> 1 + z :|: z >= 0
   from(z) -{ 2 }-> 1 + z + X2 :|: z >= 0, X2 >= 0, 1 + (1 + z) = X2
   length(z) -{ 2 }-> s(length1(Y)) :|: Y >= 0, z = 1 + X + Y, X >= 0
   length(z) -{ 2 }-> s(length1(s(activate(X'')))) :|: z = 1 + X + (1 + X''), X >= 0, X'' >= 0
   length(z) -{ 2 }-> s(length1(from(activate(X')))) :|: z = 1 + X + (1 + X'), X >= 0, X' >= 0
   length(z) -{ 2 }-> s(length1(cons(activate(X1'), X2'))) :|: X2' >= 0, X1' >= 0, X >= 0, z = 1 + X + (1 + X1' + X2')
   length(z) -{ 3 }-> s(length1(1)) :|: z - 2 >= 0
   length(z) -{ 1 }-> 0 :|: z = 1
   length(z) -{ 0 }-> 0 :|: z >= 0
   length1(z) -{ 2 }-> length(z) :|: z >= 0
   length1(z) -{ 2 }-> length(s(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(from(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(cons(activate(X1''), X2'')) :|: X1'' >= 0, z = 1 + X1'' + X2'', X2'' >= 0
   length1(z) -{ 3 }-> length(1) :|: z = 1
   nil -{ 1 }-> 1 :|: 
   s(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {nil}, {from}, {cons}, {s}, {activate}, {length1,length}
Previous analysis results are:
  nil: runtime: ?, size: O(1) [1]

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

(25) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: nil
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 1

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> s(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(cons(activate(X12), X22)) :|: X12 >= 0, X22 >= 0, z = 1 + (1 + X12 + X22)
   activate(z) -{ 3 }-> s(1) :|: z = 1 + 1
   activate(z) -{ 2 }-> from(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(cons(activate(X11), X21)) :|: z = 1 + (1 + X11 + X21), X11 >= 0, X21 >= 0
   activate(z) -{ 4 }-> cons(X, 1 + (1 + X)) :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> cons(X', 1 + (1 + X')) :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> cons(s(activate(X10)), X2) :|: X10 >= 0, z = 1 + (1 + X10) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(from(activate(X9)), X2) :|: X9 >= 0, z = 1 + (1 + X9) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(cons(activate(X13), X23), X2) :|: z = 1 + (1 + X13 + X23) + X2, X2 >= 0, X13 >= 0, X23 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 4 }-> 1 + X1 + X2' :|: z - 2 >= 0, X1 >= 0, X2' >= 0, 1 = X1, z - 2 = X2'
   activate(z) -{ 3 }-> 1 + X1' + X2' :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2, X1' >= 0, X2' >= 0, X1 = X1', X2 = X2'
   cons(z, z') -{ 1 }-> 1 + z + z' :|: z >= 0, z' >= 0
   from(z) -{ 1 }-> 1 + z :|: z >= 0
   from(z) -{ 2 }-> 1 + z + X2 :|: z >= 0, X2 >= 0, 1 + (1 + z) = X2
   length(z) -{ 2 }-> s(length1(Y)) :|: Y >= 0, z = 1 + X + Y, X >= 0
   length(z) -{ 2 }-> s(length1(s(activate(X'')))) :|: z = 1 + X + (1 + X''), X >= 0, X'' >= 0
   length(z) -{ 2 }-> s(length1(from(activate(X')))) :|: z = 1 + X + (1 + X'), X >= 0, X' >= 0
   length(z) -{ 2 }-> s(length1(cons(activate(X1'), X2'))) :|: X2' >= 0, X1' >= 0, X >= 0, z = 1 + X + (1 + X1' + X2')
   length(z) -{ 3 }-> s(length1(1)) :|: z - 2 >= 0
   length(z) -{ 1 }-> 0 :|: z = 1
   length(z) -{ 0 }-> 0 :|: z >= 0
   length1(z) -{ 2 }-> length(z) :|: z >= 0
   length1(z) -{ 2 }-> length(s(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(from(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(cons(activate(X1''), X2'')) :|: X1'' >= 0, z = 1 + X1'' + X2'', X2'' >= 0
   length1(z) -{ 3 }-> length(1) :|: z = 1
   nil -{ 1 }-> 1 :|: 
   s(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {from}, {cons}, {s}, {activate}, {length1,length}
Previous analysis results are:
  nil: runtime: O(1) [1], size: O(1) [1]

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

(27) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> s(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(cons(activate(X12), X22)) :|: X12 >= 0, X22 >= 0, z = 1 + (1 + X12 + X22)
   activate(z) -{ 3 }-> s(1) :|: z = 1 + 1
   activate(z) -{ 2 }-> from(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(cons(activate(X11), X21)) :|: z = 1 + (1 + X11 + X21), X11 >= 0, X21 >= 0
   activate(z) -{ 4 }-> cons(X, 1 + (1 + X)) :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> cons(X', 1 + (1 + X')) :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> cons(s(activate(X10)), X2) :|: X10 >= 0, z = 1 + (1 + X10) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(from(activate(X9)), X2) :|: X9 >= 0, z = 1 + (1 + X9) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(cons(activate(X13), X23), X2) :|: z = 1 + (1 + X13 + X23) + X2, X2 >= 0, X13 >= 0, X23 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 4 }-> 1 + X1 + X2' :|: z - 2 >= 0, X1 >= 0, X2' >= 0, 1 = X1, z - 2 = X2'
   activate(z) -{ 3 }-> 1 + X1' + X2' :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2, X1' >= 0, X2' >= 0, X1 = X1', X2 = X2'
   cons(z, z') -{ 1 }-> 1 + z + z' :|: z >= 0, z' >= 0
   from(z) -{ 1 }-> 1 + z :|: z >= 0
   from(z) -{ 2 }-> 1 + z + X2 :|: z >= 0, X2 >= 0, 1 + (1 + z) = X2
   length(z) -{ 2 }-> s(length1(Y)) :|: Y >= 0, z = 1 + X + Y, X >= 0
   length(z) -{ 2 }-> s(length1(s(activate(X'')))) :|: z = 1 + X + (1 + X''), X >= 0, X'' >= 0
   length(z) -{ 2 }-> s(length1(from(activate(X')))) :|: z = 1 + X + (1 + X'), X >= 0, X' >= 0
   length(z) -{ 2 }-> s(length1(cons(activate(X1'), X2'))) :|: X2' >= 0, X1' >= 0, X >= 0, z = 1 + X + (1 + X1' + X2')
   length(z) -{ 3 }-> s(length1(1)) :|: z - 2 >= 0
   length(z) -{ 1 }-> 0 :|: z = 1
   length(z) -{ 0 }-> 0 :|: z >= 0
   length1(z) -{ 2 }-> length(z) :|: z >= 0
   length1(z) -{ 2 }-> length(s(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(from(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(cons(activate(X1''), X2'')) :|: X1'' >= 0, z = 1 + X1'' + X2'', X2'' >= 0
   length1(z) -{ 3 }-> length(1) :|: z = 1
   nil -{ 1 }-> 1 :|: 
   s(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {from}, {cons}, {s}, {activate}, {length1,length}
Previous analysis results are:
  nil: runtime: O(1) [1], size: O(1) [1]

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

(29) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: from
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: 3 + 2*z

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> s(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(cons(activate(X12), X22)) :|: X12 >= 0, X22 >= 0, z = 1 + (1 + X12 + X22)
   activate(z) -{ 3 }-> s(1) :|: z = 1 + 1
   activate(z) -{ 2 }-> from(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(cons(activate(X11), X21)) :|: z = 1 + (1 + X11 + X21), X11 >= 0, X21 >= 0
   activate(z) -{ 4 }-> cons(X, 1 + (1 + X)) :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> cons(X', 1 + (1 + X')) :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> cons(s(activate(X10)), X2) :|: X10 >= 0, z = 1 + (1 + X10) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(from(activate(X9)), X2) :|: X9 >= 0, z = 1 + (1 + X9) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(cons(activate(X13), X23), X2) :|: z = 1 + (1 + X13 + X23) + X2, X2 >= 0, X13 >= 0, X23 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 4 }-> 1 + X1 + X2' :|: z - 2 >= 0, X1 >= 0, X2' >= 0, 1 = X1, z - 2 = X2'
   activate(z) -{ 3 }-> 1 + X1' + X2' :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2, X1' >= 0, X2' >= 0, X1 = X1', X2 = X2'
   cons(z, z') -{ 1 }-> 1 + z + z' :|: z >= 0, z' >= 0
   from(z) -{ 1 }-> 1 + z :|: z >= 0
   from(z) -{ 2 }-> 1 + z + X2 :|: z >= 0, X2 >= 0, 1 + (1 + z) = X2
   length(z) -{ 2 }-> s(length1(Y)) :|: Y >= 0, z = 1 + X + Y, X >= 0
   length(z) -{ 2 }-> s(length1(s(activate(X'')))) :|: z = 1 + X + (1 + X''), X >= 0, X'' >= 0
   length(z) -{ 2 }-> s(length1(from(activate(X')))) :|: z = 1 + X + (1 + X'), X >= 0, X' >= 0
   length(z) -{ 2 }-> s(length1(cons(activate(X1'), X2'))) :|: X2' >= 0, X1' >= 0, X >= 0, z = 1 + X + (1 + X1' + X2')
   length(z) -{ 3 }-> s(length1(1)) :|: z - 2 >= 0
   length(z) -{ 1 }-> 0 :|: z = 1
   length(z) -{ 0 }-> 0 :|: z >= 0
   length1(z) -{ 2 }-> length(z) :|: z >= 0
   length1(z) -{ 2 }-> length(s(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(from(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(cons(activate(X1''), X2'')) :|: X1'' >= 0, z = 1 + X1'' + X2'', X2'' >= 0
   length1(z) -{ 3 }-> length(1) :|: z = 1
   nil -{ 1 }-> 1 :|: 
   s(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {from}, {cons}, {s}, {activate}, {length1,length}
Previous analysis results are:
  nil: runtime: O(1) [1], size: O(1) [1]
  from: runtime: ?, size: O(n^1) [3 + 2*z]

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

(31) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: from
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 2

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> s(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(cons(activate(X12), X22)) :|: X12 >= 0, X22 >= 0, z = 1 + (1 + X12 + X22)
   activate(z) -{ 3 }-> s(1) :|: z = 1 + 1
   activate(z) -{ 2 }-> from(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(cons(activate(X11), X21)) :|: z = 1 + (1 + X11 + X21), X11 >= 0, X21 >= 0
   activate(z) -{ 4 }-> cons(X, 1 + (1 + X)) :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> cons(X', 1 + (1 + X')) :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> cons(s(activate(X10)), X2) :|: X10 >= 0, z = 1 + (1 + X10) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(from(activate(X9)), X2) :|: X9 >= 0, z = 1 + (1 + X9) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(cons(activate(X13), X23), X2) :|: z = 1 + (1 + X13 + X23) + X2, X2 >= 0, X13 >= 0, X23 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 4 }-> 1 + X1 + X2' :|: z - 2 >= 0, X1 >= 0, X2' >= 0, 1 = X1, z - 2 = X2'
   activate(z) -{ 3 }-> 1 + X1' + X2' :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2, X1' >= 0, X2' >= 0, X1 = X1', X2 = X2'
   cons(z, z') -{ 1 }-> 1 + z + z' :|: z >= 0, z' >= 0
   from(z) -{ 1 }-> 1 + z :|: z >= 0
   from(z) -{ 2 }-> 1 + z + X2 :|: z >= 0, X2 >= 0, 1 + (1 + z) = X2
   length(z) -{ 2 }-> s(length1(Y)) :|: Y >= 0, z = 1 + X + Y, X >= 0
   length(z) -{ 2 }-> s(length1(s(activate(X'')))) :|: z = 1 + X + (1 + X''), X >= 0, X'' >= 0
   length(z) -{ 2 }-> s(length1(from(activate(X')))) :|: z = 1 + X + (1 + X'), X >= 0, X' >= 0
   length(z) -{ 2 }-> s(length1(cons(activate(X1'), X2'))) :|: X2' >= 0, X1' >= 0, X >= 0, z = 1 + X + (1 + X1' + X2')
   length(z) -{ 3 }-> s(length1(1)) :|: z - 2 >= 0
   length(z) -{ 1 }-> 0 :|: z = 1
   length(z) -{ 0 }-> 0 :|: z >= 0
   length1(z) -{ 2 }-> length(z) :|: z >= 0
   length1(z) -{ 2 }-> length(s(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(from(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(cons(activate(X1''), X2'')) :|: X1'' >= 0, z = 1 + X1'' + X2'', X2'' >= 0
   length1(z) -{ 3 }-> length(1) :|: z = 1
   nil -{ 1 }-> 1 :|: 
   s(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {cons}, {s}, {activate}, {length1,length}
Previous analysis results are:
  nil: runtime: O(1) [1], size: O(1) [1]
  from: runtime: O(1) [2], size: O(n^1) [3 + 2*z]

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

(33) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> s(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(cons(activate(X12), X22)) :|: X12 >= 0, X22 >= 0, z = 1 + (1 + X12 + X22)
   activate(z) -{ 3 }-> s(1) :|: z = 1 + 1
   activate(z) -{ 2 }-> from(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(cons(activate(X11), X21)) :|: z = 1 + (1 + X11 + X21), X11 >= 0, X21 >= 0
   activate(z) -{ 4 }-> cons(X, 1 + (1 + X)) :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> cons(X', 1 + (1 + X')) :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> cons(s(activate(X10)), X2) :|: X10 >= 0, z = 1 + (1 + X10) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(from(activate(X9)), X2) :|: X9 >= 0, z = 1 + (1 + X9) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(cons(activate(X13), X23), X2) :|: z = 1 + (1 + X13 + X23) + X2, X2 >= 0, X13 >= 0, X23 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 4 }-> 1 + X1 + X2' :|: z - 2 >= 0, X1 >= 0, X2' >= 0, 1 = X1, z - 2 = X2'
   activate(z) -{ 3 }-> 1 + X1' + X2' :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2, X1' >= 0, X2' >= 0, X1 = X1', X2 = X2'
   cons(z, z') -{ 1 }-> 1 + z + z' :|: z >= 0, z' >= 0
   from(z) -{ 1 }-> 1 + z :|: z >= 0
   from(z) -{ 2 }-> 1 + z + X2 :|: z >= 0, X2 >= 0, 1 + (1 + z) = X2
   length(z) -{ 2 }-> s(length1(Y)) :|: Y >= 0, z = 1 + X + Y, X >= 0
   length(z) -{ 2 }-> s(length1(s(activate(X'')))) :|: z = 1 + X + (1 + X''), X >= 0, X'' >= 0
   length(z) -{ 2 }-> s(length1(from(activate(X')))) :|: z = 1 + X + (1 + X'), X >= 0, X' >= 0
   length(z) -{ 2 }-> s(length1(cons(activate(X1'), X2'))) :|: X2' >= 0, X1' >= 0, X >= 0, z = 1 + X + (1 + X1' + X2')
   length(z) -{ 3 }-> s(length1(1)) :|: z - 2 >= 0
   length(z) -{ 1 }-> 0 :|: z = 1
   length(z) -{ 0 }-> 0 :|: z >= 0
   length1(z) -{ 2 }-> length(z) :|: z >= 0
   length1(z) -{ 2 }-> length(s(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(from(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(cons(activate(X1''), X2'')) :|: X1'' >= 0, z = 1 + X1'' + X2'', X2'' >= 0
   length1(z) -{ 3 }-> length(1) :|: z = 1
   nil -{ 1 }-> 1 :|: 
   s(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {cons}, {s}, {activate}, {length1,length}
Previous analysis results are:
  nil: runtime: O(1) [1], size: O(1) [1]
  from: runtime: O(1) [2], size: O(n^1) [3 + 2*z]

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

(35) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: cons
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: 1 + z + z'

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> s(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(cons(activate(X12), X22)) :|: X12 >= 0, X22 >= 0, z = 1 + (1 + X12 + X22)
   activate(z) -{ 3 }-> s(1) :|: z = 1 + 1
   activate(z) -{ 2 }-> from(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(cons(activate(X11), X21)) :|: z = 1 + (1 + X11 + X21), X11 >= 0, X21 >= 0
   activate(z) -{ 4 }-> cons(X, 1 + (1 + X)) :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> cons(X', 1 + (1 + X')) :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> cons(s(activate(X10)), X2) :|: X10 >= 0, z = 1 + (1 + X10) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(from(activate(X9)), X2) :|: X9 >= 0, z = 1 + (1 + X9) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(cons(activate(X13), X23), X2) :|: z = 1 + (1 + X13 + X23) + X2, X2 >= 0, X13 >= 0, X23 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 4 }-> 1 + X1 + X2' :|: z - 2 >= 0, X1 >= 0, X2' >= 0, 1 = X1, z - 2 = X2'
   activate(z) -{ 3 }-> 1 + X1' + X2' :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2, X1' >= 0, X2' >= 0, X1 = X1', X2 = X2'
   cons(z, z') -{ 1 }-> 1 + z + z' :|: z >= 0, z' >= 0
   from(z) -{ 1 }-> 1 + z :|: z >= 0
   from(z) -{ 2 }-> 1 + z + X2 :|: z >= 0, X2 >= 0, 1 + (1 + z) = X2
   length(z) -{ 2 }-> s(length1(Y)) :|: Y >= 0, z = 1 + X + Y, X >= 0
   length(z) -{ 2 }-> s(length1(s(activate(X'')))) :|: z = 1 + X + (1 + X''), X >= 0, X'' >= 0
   length(z) -{ 2 }-> s(length1(from(activate(X')))) :|: z = 1 + X + (1 + X'), X >= 0, X' >= 0
   length(z) -{ 2 }-> s(length1(cons(activate(X1'), X2'))) :|: X2' >= 0, X1' >= 0, X >= 0, z = 1 + X + (1 + X1' + X2')
   length(z) -{ 3 }-> s(length1(1)) :|: z - 2 >= 0
   length(z) -{ 1 }-> 0 :|: z = 1
   length(z) -{ 0 }-> 0 :|: z >= 0
   length1(z) -{ 2 }-> length(z) :|: z >= 0
   length1(z) -{ 2 }-> length(s(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(from(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(cons(activate(X1''), X2'')) :|: X1'' >= 0, z = 1 + X1'' + X2'', X2'' >= 0
   length1(z) -{ 3 }-> length(1) :|: z = 1
   nil -{ 1 }-> 1 :|: 
   s(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {cons}, {s}, {activate}, {length1,length}
Previous analysis results are:
  nil: runtime: O(1) [1], size: O(1) [1]
  from: runtime: O(1) [2], size: O(n^1) [3 + 2*z]
  cons: runtime: ?, size: O(n^1) [1 + z + z']

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

(37) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: cons
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 1

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

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

   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> s(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(cons(activate(X12), X22)) :|: X12 >= 0, X22 >= 0, z = 1 + (1 + X12 + X22)
   activate(z) -{ 3 }-> s(1) :|: z = 1 + 1
   activate(z) -{ 2 }-> from(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(cons(activate(X11), X21)) :|: z = 1 + (1 + X11 + X21), X11 >= 0, X21 >= 0
   activate(z) -{ 4 }-> cons(X, 1 + (1 + X)) :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> cons(X', 1 + (1 + X')) :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 2 }-> cons(s(activate(X10)), X2) :|: X10 >= 0, z = 1 + (1 + X10) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(from(activate(X9)), X2) :|: X9 >= 0, z = 1 + (1 + X9) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(cons(activate(X13), X23), X2) :|: z = 1 + (1 + X13 + X23) + X2, X2 >= 0, X13 >= 0, X23 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 4 }-> 1 + X1 + X2' :|: z - 2 >= 0, X1 >= 0, X2' >= 0, 1 = X1, z - 2 = X2'
   activate(z) -{ 3 }-> 1 + X1' + X2' :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2, X1' >= 0, X2' >= 0, X1 = X1', X2 = X2'
   cons(z, z') -{ 1 }-> 1 + z + z' :|: z >= 0, z' >= 0
   from(z) -{ 1 }-> 1 + z :|: z >= 0
   from(z) -{ 2 }-> 1 + z + X2 :|: z >= 0, X2 >= 0, 1 + (1 + z) = X2
   length(z) -{ 2 }-> s(length1(Y)) :|: Y >= 0, z = 1 + X + Y, X >= 0
   length(z) -{ 2 }-> s(length1(s(activate(X'')))) :|: z = 1 + X + (1 + X''), X >= 0, X'' >= 0
   length(z) -{ 2 }-> s(length1(from(activate(X')))) :|: z = 1 + X + (1 + X'), X >= 0, X' >= 0
   length(z) -{ 2 }-> s(length1(cons(activate(X1'), X2'))) :|: X2' >= 0, X1' >= 0, X >= 0, z = 1 + X + (1 + X1' + X2')
   length(z) -{ 3 }-> s(length1(1)) :|: z - 2 >= 0
   length(z) -{ 1 }-> 0 :|: z = 1
   length(z) -{ 0 }-> 0 :|: z >= 0
   length1(z) -{ 2 }-> length(z) :|: z >= 0
   length1(z) -{ 2 }-> length(s(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(from(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(cons(activate(X1''), X2'')) :|: X1'' >= 0, z = 1 + X1'' + X2'', X2'' >= 0
   length1(z) -{ 3 }-> length(1) :|: z = 1
   nil -{ 1 }-> 1 :|: 
   s(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {s}, {activate}, {length1,length}
Previous analysis results are:
  nil: runtime: O(1) [1], size: O(1) [1]
  from: runtime: O(1) [2], size: O(n^1) [3 + 2*z]
  cons: runtime: O(1) [1], size: O(n^1) [1 + z + z']

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

(39) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

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

   activate(z) -{ 4 }-> s :|: s >= 0, s <= X' + (1 + (1 + X')) + 1, z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 5 }-> s' :|: s' >= 0, s' <= X + (1 + (1 + X)) + 1, z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> s(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(cons(activate(X12), X22)) :|: X12 >= 0, X22 >= 0, z = 1 + (1 + X12 + X22)
   activate(z) -{ 3 }-> s(1) :|: z = 1 + 1
   activate(z) -{ 2 }-> from(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(cons(activate(X11), X21)) :|: z = 1 + (1 + X11 + X21), X11 >= 0, X21 >= 0
   activate(z) -{ 2 }-> cons(s(activate(X10)), X2) :|: X10 >= 0, z = 1 + (1 + X10) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(from(activate(X9)), X2) :|: X9 >= 0, z = 1 + (1 + X9) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(cons(activate(X13), X23), X2) :|: z = 1 + (1 + X13 + X23) + X2, X2 >= 0, X13 >= 0, X23 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 4 }-> 1 + X1 + X2' :|: z - 2 >= 0, X1 >= 0, X2' >= 0, 1 = X1, z - 2 = X2'
   activate(z) -{ 3 }-> 1 + X1' + X2' :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2, X1' >= 0, X2' >= 0, X1 = X1', X2 = X2'
   cons(z, z') -{ 1 }-> 1 + z + z' :|: z >= 0, z' >= 0
   from(z) -{ 1 }-> 1 + z :|: z >= 0
   from(z) -{ 2 }-> 1 + z + X2 :|: z >= 0, X2 >= 0, 1 + (1 + z) = X2
   length(z) -{ 2 }-> s(length1(Y)) :|: Y >= 0, z = 1 + X + Y, X >= 0
   length(z) -{ 2 }-> s(length1(s(activate(X'')))) :|: z = 1 + X + (1 + X''), X >= 0, X'' >= 0
   length(z) -{ 2 }-> s(length1(from(activate(X')))) :|: z = 1 + X + (1 + X'), X >= 0, X' >= 0
   length(z) -{ 2 }-> s(length1(cons(activate(X1'), X2'))) :|: X2' >= 0, X1' >= 0, X >= 0, z = 1 + X + (1 + X1' + X2')
   length(z) -{ 3 }-> s(length1(1)) :|: z - 2 >= 0
   length(z) -{ 1 }-> 0 :|: z = 1
   length(z) -{ 0 }-> 0 :|: z >= 0
   length1(z) -{ 2 }-> length(z) :|: z >= 0
   length1(z) -{ 2 }-> length(s(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(from(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(cons(activate(X1''), X2'')) :|: X1'' >= 0, z = 1 + X1'' + X2'', X2'' >= 0
   length1(z) -{ 3 }-> length(1) :|: z = 1
   nil -{ 1 }-> 1 :|: 
   s(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {s}, {activate}, {length1,length}
Previous analysis results are:
  nil: runtime: O(1) [1], size: O(1) [1]
  from: runtime: O(1) [2], size: O(n^1) [3 + 2*z]
  cons: runtime: O(1) [1], size: O(n^1) [1 + z + z']

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

(41) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: s
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: 1 + z

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

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

   activate(z) -{ 4 }-> s :|: s >= 0, s <= X' + (1 + (1 + X')) + 1, z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 5 }-> s' :|: s' >= 0, s' <= X + (1 + (1 + X)) + 1, z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> s(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(cons(activate(X12), X22)) :|: X12 >= 0, X22 >= 0, z = 1 + (1 + X12 + X22)
   activate(z) -{ 3 }-> s(1) :|: z = 1 + 1
   activate(z) -{ 2 }-> from(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(cons(activate(X11), X21)) :|: z = 1 + (1 + X11 + X21), X11 >= 0, X21 >= 0
   activate(z) -{ 2 }-> cons(s(activate(X10)), X2) :|: X10 >= 0, z = 1 + (1 + X10) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(from(activate(X9)), X2) :|: X9 >= 0, z = 1 + (1 + X9) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(cons(activate(X13), X23), X2) :|: z = 1 + (1 + X13 + X23) + X2, X2 >= 0, X13 >= 0, X23 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 4 }-> 1 + X1 + X2' :|: z - 2 >= 0, X1 >= 0, X2' >= 0, 1 = X1, z - 2 = X2'
   activate(z) -{ 3 }-> 1 + X1' + X2' :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2, X1' >= 0, X2' >= 0, X1 = X1', X2 = X2'
   cons(z, z') -{ 1 }-> 1 + z + z' :|: z >= 0, z' >= 0
   from(z) -{ 1 }-> 1 + z :|: z >= 0
   from(z) -{ 2 }-> 1 + z + X2 :|: z >= 0, X2 >= 0, 1 + (1 + z) = X2
   length(z) -{ 2 }-> s(length1(Y)) :|: Y >= 0, z = 1 + X + Y, X >= 0
   length(z) -{ 2 }-> s(length1(s(activate(X'')))) :|: z = 1 + X + (1 + X''), X >= 0, X'' >= 0
   length(z) -{ 2 }-> s(length1(from(activate(X')))) :|: z = 1 + X + (1 + X'), X >= 0, X' >= 0
   length(z) -{ 2 }-> s(length1(cons(activate(X1'), X2'))) :|: X2' >= 0, X1' >= 0, X >= 0, z = 1 + X + (1 + X1' + X2')
   length(z) -{ 3 }-> s(length1(1)) :|: z - 2 >= 0
   length(z) -{ 1 }-> 0 :|: z = 1
   length(z) -{ 0 }-> 0 :|: z >= 0
   length1(z) -{ 2 }-> length(z) :|: z >= 0
   length1(z) -{ 2 }-> length(s(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(from(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(cons(activate(X1''), X2'')) :|: X1'' >= 0, z = 1 + X1'' + X2'', X2'' >= 0
   length1(z) -{ 3 }-> length(1) :|: z = 1
   nil -{ 1 }-> 1 :|: 
   s(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {s}, {activate}, {length1,length}
Previous analysis results are:
  nil: runtime: O(1) [1], size: O(1) [1]
  from: runtime: O(1) [2], size: O(n^1) [3 + 2*z]
  cons: runtime: O(1) [1], size: O(n^1) [1 + z + z']
  s: runtime: ?, size: O(n^1) [1 + z]

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

(43) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: s
after applying outer abstraction to obtain an ITS,
resulting in: O(1) with polynomial bound: 1

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

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

   activate(z) -{ 4 }-> s :|: s >= 0, s <= X' + (1 + (1 + X')) + 1, z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 5 }-> s' :|: s' >= 0, s' <= X + (1 + (1 + X)) + 1, z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> s(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(cons(activate(X12), X22)) :|: X12 >= 0, X22 >= 0, z = 1 + (1 + X12 + X22)
   activate(z) -{ 3 }-> s(1) :|: z = 1 + 1
   activate(z) -{ 2 }-> from(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(cons(activate(X11), X21)) :|: z = 1 + (1 + X11 + X21), X11 >= 0, X21 >= 0
   activate(z) -{ 2 }-> cons(s(activate(X10)), X2) :|: X10 >= 0, z = 1 + (1 + X10) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(from(activate(X9)), X2) :|: X9 >= 0, z = 1 + (1 + X9) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(cons(activate(X13), X23), X2) :|: z = 1 + (1 + X13 + X23) + X2, X2 >= 0, X13 >= 0, X23 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 4 }-> 1 + X1 + X2' :|: z - 2 >= 0, X1 >= 0, X2' >= 0, 1 = X1, z - 2 = X2'
   activate(z) -{ 3 }-> 1 + X1' + X2' :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2, X1' >= 0, X2' >= 0, X1 = X1', X2 = X2'
   cons(z, z') -{ 1 }-> 1 + z + z' :|: z >= 0, z' >= 0
   from(z) -{ 1 }-> 1 + z :|: z >= 0
   from(z) -{ 2 }-> 1 + z + X2 :|: z >= 0, X2 >= 0, 1 + (1 + z) = X2
   length(z) -{ 2 }-> s(length1(Y)) :|: Y >= 0, z = 1 + X + Y, X >= 0
   length(z) -{ 2 }-> s(length1(s(activate(X'')))) :|: z = 1 + X + (1 + X''), X >= 0, X'' >= 0
   length(z) -{ 2 }-> s(length1(from(activate(X')))) :|: z = 1 + X + (1 + X'), X >= 0, X' >= 0
   length(z) -{ 2 }-> s(length1(cons(activate(X1'), X2'))) :|: X2' >= 0, X1' >= 0, X >= 0, z = 1 + X + (1 + X1' + X2')
   length(z) -{ 3 }-> s(length1(1)) :|: z - 2 >= 0
   length(z) -{ 1 }-> 0 :|: z = 1
   length(z) -{ 0 }-> 0 :|: z >= 0
   length1(z) -{ 2 }-> length(z) :|: z >= 0
   length1(z) -{ 2 }-> length(s(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(from(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(cons(activate(X1''), X2'')) :|: X1'' >= 0, z = 1 + X1'' + X2'', X2'' >= 0
   length1(z) -{ 3 }-> length(1) :|: z = 1
   nil -{ 1 }-> 1 :|: 
   s(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {activate}, {length1,length}
Previous analysis results are:
  nil: runtime: O(1) [1], size: O(1) [1]
  from: runtime: O(1) [2], size: O(n^1) [3 + 2*z]
  cons: runtime: O(1) [1], size: O(n^1) [1 + z + z']
  s: runtime: O(1) [1], size: O(n^1) [1 + z]

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

(45) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

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

   activate(z) -{ 4 }-> s :|: s >= 0, s <= X' + (1 + (1 + X')) + 1, z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 5 }-> s' :|: s' >= 0, s' <= X + (1 + (1 + X)) + 1, z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 4 }-> s'' :|: s'' >= 0, s'' <= 1 + 1, z = 1 + 1
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> s(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(cons(activate(X12), X22)) :|: X12 >= 0, X22 >= 0, z = 1 + (1 + X12 + X22)
   activate(z) -{ 2 }-> from(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(cons(activate(X11), X21)) :|: z = 1 + (1 + X11 + X21), X11 >= 0, X21 >= 0
   activate(z) -{ 2 }-> cons(s(activate(X10)), X2) :|: X10 >= 0, z = 1 + (1 + X10) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(from(activate(X9)), X2) :|: X9 >= 0, z = 1 + (1 + X9) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(cons(activate(X13), X23), X2) :|: z = 1 + (1 + X13 + X23) + X2, X2 >= 0, X13 >= 0, X23 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 4 }-> 1 + X1 + X2' :|: z - 2 >= 0, X1 >= 0, X2' >= 0, 1 = X1, z - 2 = X2'
   activate(z) -{ 3 }-> 1 + X1' + X2' :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2, X1' >= 0, X2' >= 0, X1 = X1', X2 = X2'
   cons(z, z') -{ 1 }-> 1 + z + z' :|: z >= 0, z' >= 0
   from(z) -{ 1 }-> 1 + z :|: z >= 0
   from(z) -{ 2 }-> 1 + z + X2 :|: z >= 0, X2 >= 0, 1 + (1 + z) = X2
   length(z) -{ 2 }-> s(length1(Y)) :|: Y >= 0, z = 1 + X + Y, X >= 0
   length(z) -{ 2 }-> s(length1(s(activate(X'')))) :|: z = 1 + X + (1 + X''), X >= 0, X'' >= 0
   length(z) -{ 2 }-> s(length1(from(activate(X')))) :|: z = 1 + X + (1 + X'), X >= 0, X' >= 0
   length(z) -{ 2 }-> s(length1(cons(activate(X1'), X2'))) :|: X2' >= 0, X1' >= 0, X >= 0, z = 1 + X + (1 + X1' + X2')
   length(z) -{ 3 }-> s(length1(1)) :|: z - 2 >= 0
   length(z) -{ 1 }-> 0 :|: z = 1
   length(z) -{ 0 }-> 0 :|: z >= 0
   length1(z) -{ 2 }-> length(z) :|: z >= 0
   length1(z) -{ 2 }-> length(s(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(from(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(cons(activate(X1''), X2'')) :|: X1'' >= 0, z = 1 + X1'' + X2'', X2'' >= 0
   length1(z) -{ 3 }-> length(1) :|: z = 1
   nil -{ 1 }-> 1 :|: 
   s(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {activate}, {length1,length}
Previous analysis results are:
  nil: runtime: O(1) [1], size: O(1) [1]
  from: runtime: O(1) [2], size: O(n^1) [3 + 2*z]
  cons: runtime: O(1) [1], size: O(n^1) [1 + z + z']
  s: runtime: O(1) [1], size: O(n^1) [1 + z]

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

(47) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using KoAT for: activate
after applying outer abstraction to obtain an ITS,
resulting in: EXP with polynomial bound: ?

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

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

   activate(z) -{ 4 }-> s :|: s >= 0, s <= X' + (1 + (1 + X')) + 1, z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 5 }-> s' :|: s' >= 0, s' <= X + (1 + (1 + X)) + 1, z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 4 }-> s'' :|: s'' >= 0, s'' <= 1 + 1, z = 1 + 1
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> s(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(cons(activate(X12), X22)) :|: X12 >= 0, X22 >= 0, z = 1 + (1 + X12 + X22)
   activate(z) -{ 2 }-> from(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(cons(activate(X11), X21)) :|: z = 1 + (1 + X11 + X21), X11 >= 0, X21 >= 0
   activate(z) -{ 2 }-> cons(s(activate(X10)), X2) :|: X10 >= 0, z = 1 + (1 + X10) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(from(activate(X9)), X2) :|: X9 >= 0, z = 1 + (1 + X9) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(cons(activate(X13), X23), X2) :|: z = 1 + (1 + X13 + X23) + X2, X2 >= 0, X13 >= 0, X23 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 4 }-> 1 + X1 + X2' :|: z - 2 >= 0, X1 >= 0, X2' >= 0, 1 = X1, z - 2 = X2'
   activate(z) -{ 3 }-> 1 + X1' + X2' :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2, X1' >= 0, X2' >= 0, X1 = X1', X2 = X2'
   cons(z, z') -{ 1 }-> 1 + z + z' :|: z >= 0, z' >= 0
   from(z) -{ 1 }-> 1 + z :|: z >= 0
   from(z) -{ 2 }-> 1 + z + X2 :|: z >= 0, X2 >= 0, 1 + (1 + z) = X2
   length(z) -{ 2 }-> s(length1(Y)) :|: Y >= 0, z = 1 + X + Y, X >= 0
   length(z) -{ 2 }-> s(length1(s(activate(X'')))) :|: z = 1 + X + (1 + X''), X >= 0, X'' >= 0
   length(z) -{ 2 }-> s(length1(from(activate(X')))) :|: z = 1 + X + (1 + X'), X >= 0, X' >= 0
   length(z) -{ 2 }-> s(length1(cons(activate(X1'), X2'))) :|: X2' >= 0, X1' >= 0, X >= 0, z = 1 + X + (1 + X1' + X2')
   length(z) -{ 3 }-> s(length1(1)) :|: z - 2 >= 0
   length(z) -{ 1 }-> 0 :|: z = 1
   length(z) -{ 0 }-> 0 :|: z >= 0
   length1(z) -{ 2 }-> length(z) :|: z >= 0
   length1(z) -{ 2 }-> length(s(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(from(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(cons(activate(X1''), X2'')) :|: X1'' >= 0, z = 1 + X1'' + X2'', X2'' >= 0
   length1(z) -{ 3 }-> length(1) :|: z = 1
   nil -{ 1 }-> 1 :|: 
   s(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {activate}, {length1,length}
Previous analysis results are:
  nil: runtime: O(1) [1], size: O(1) [1]
  from: runtime: O(1) [2], size: O(n^1) [3 + 2*z]
  cons: runtime: O(1) [1], size: O(n^1) [1 + z + z']
  s: runtime: O(1) [1], size: O(n^1) [1 + z]
  activate: runtime: ?, size: EXP

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

(49) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using KoAT for: activate
after applying outer abstraction to obtain an ITS,
resulting in: O(n^1) with polynomial bound: 30 + 37*z

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

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

   activate(z) -{ 4 }-> s :|: s >= 0, s <= X' + (1 + (1 + X')) + 1, z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 5 }-> s' :|: s' >= 0, s' <= X + (1 + (1 + X)) + 1, z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 4 }-> s'' :|: s'' >= 0, s'' <= 1 + 1, z = 1 + 1
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> s(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> s(cons(activate(X12), X22)) :|: X12 >= 0, X22 >= 0, z = 1 + (1 + X12 + X22)
   activate(z) -{ 2 }-> from(s(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(from(activate(z - 2))) :|: z - 2 >= 0
   activate(z) -{ 2 }-> from(cons(activate(X11), X21)) :|: z = 1 + (1 + X11 + X21), X11 >= 0, X21 >= 0
   activate(z) -{ 2 }-> cons(s(activate(X10)), X2) :|: X10 >= 0, z = 1 + (1 + X10) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(from(activate(X9)), X2) :|: X9 >= 0, z = 1 + (1 + X9) + X2, X2 >= 0
   activate(z) -{ 2 }-> cons(cons(activate(X13), X23), X2) :|: z = 1 + (1 + X13 + X23) + X2, X2 >= 0, X13 >= 0, X23 >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 4 }-> 1 + X1 + X2' :|: z - 2 >= 0, X1 >= 0, X2' >= 0, 1 = X1, z - 2 = X2'
   activate(z) -{ 3 }-> 1 + X1' + X2' :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2, X1' >= 0, X2' >= 0, X1 = X1', X2 = X2'
   cons(z, z') -{ 1 }-> 1 + z + z' :|: z >= 0, z' >= 0
   from(z) -{ 1 }-> 1 + z :|: z >= 0
   from(z) -{ 2 }-> 1 + z + X2 :|: z >= 0, X2 >= 0, 1 + (1 + z) = X2
   length(z) -{ 2 }-> s(length1(Y)) :|: Y >= 0, z = 1 + X + Y, X >= 0
   length(z) -{ 2 }-> s(length1(s(activate(X'')))) :|: z = 1 + X + (1 + X''), X >= 0, X'' >= 0
   length(z) -{ 2 }-> s(length1(from(activate(X')))) :|: z = 1 + X + (1 + X'), X >= 0, X' >= 0
   length(z) -{ 2 }-> s(length1(cons(activate(X1'), X2'))) :|: X2' >= 0, X1' >= 0, X >= 0, z = 1 + X + (1 + X1' + X2')
   length(z) -{ 3 }-> s(length1(1)) :|: z - 2 >= 0
   length(z) -{ 1 }-> 0 :|: z = 1
   length(z) -{ 0 }-> 0 :|: z >= 0
   length1(z) -{ 2 }-> length(z) :|: z >= 0
   length1(z) -{ 2 }-> length(s(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(from(activate(z - 1))) :|: z - 1 >= 0
   length1(z) -{ 2 }-> length(cons(activate(X1''), X2'')) :|: X1'' >= 0, z = 1 + X1'' + X2'', X2'' >= 0
   length1(z) -{ 3 }-> length(1) :|: z = 1
   nil -{ 1 }-> 1 :|: 
   s(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {length1,length}
Previous analysis results are:
  nil: runtime: O(1) [1], size: O(1) [1]
  from: runtime: O(1) [2], size: O(n^1) [3 + 2*z]
  cons: runtime: O(1) [1], size: O(n^1) [1 + z + z']
  s: runtime: O(1) [1], size: O(n^1) [1 + z]
  activate: runtime: O(n^1) [30 + 37*z], size: EXP

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

(51) ResultPropagationProof (UPPER BOUND(ID))
Applied inner abstraction using the recently inferred runtime/size bounds where possible.
----------------------------------------

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

   activate(z) -{ 4 }-> s :|: s >= 0, s <= X' + (1 + (1 + X')) + 1, z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 5 }-> s' :|: s' >= 0, s' <= X + (1 + (1 + X)) + 1, z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 4 }-> s'' :|: s'' >= 0, s'' <= 1 + 1, z = 1 + 1
   activate(z) -{ 34 + 37*X13 }-> s12 :|: s10 >= 0, s10 <= inf2, s11 >= 0, s11 <= s10 + X23 + 1, s12 >= 0, s12 <= s11 + X2 + 1, z = 1 + (1 + X13 + X23) + X2, X2 >= 0, X13 >= 0, X23 >= 0
   activate(z) -{ 34 + 37*X12 }-> s17 :|: s15 >= 0, s15 <= inf4, s16 >= 0, s16 <= s15 + X22 + 1, s17 >= 0, s17 <= s16 + 1, X12 >= 0, X22 >= 0, z = 1 + (1 + X12 + X22)
   activate(z) -{ 34 + 37*X10 }-> s20 :|: s18 >= 0, s18 <= inf5, s19 >= 0, s19 <= s18 + 1, s20 >= 0, s20 <= s19 + X2 + 1, X10 >= 0, z = 1 + (1 + X10) + X2, X2 >= 0
   activate(z) -{ -38 + 37*z }-> s25 :|: s23 >= 0, s23 <= inf7, s24 >= 0, s24 <= 2 * s23 + 3, s25 >= 0, s25 <= 2 * s24 + 3, z - 2 >= 0
   activate(z) -{ -39 + 37*z }-> s30 :|: s28 >= 0, s28 <= inf9, s29 >= 0, s29 <= s28 + 1, s30 >= 0, s30 <= 2 * s29 + 3, z - 2 >= 0
   activate(z) -{ -39 + 37*z }-> s33 :|: s31 >= 0, s31 <= inf10, s32 >= 0, s32 <= 2 * s31 + 3, s33 >= 0, s33 <= s32 + 1, z - 2 >= 0
   activate(z) -{ 35 + 37*X11 }-> s36 :|: s34 >= 0, s34 <= inf11, s35 >= 0, s35 <= s34 + X21 + 1, s36 >= 0, s36 <= 2 * s35 + 3, z = 1 + (1 + X11 + X21), X11 >= 0, X21 >= 0
   activate(z) -{ 35 + 37*X9 }-> s39 :|: s37 >= 0, s37 <= inf12, s38 >= 0, s38 <= 2 * s37 + 3, s39 >= 0, s39 <= s38 + X2 + 1, X9 >= 0, z = 1 + (1 + X9) + X2, X2 >= 0
   activate(z) -{ -40 + 37*z }-> s7 :|: s5 >= 0, s5 <= inf'', s6 >= 0, s6 <= s5 + 1, s7 >= 0, s7 <= s6 + 1, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 4 }-> 1 + X1 + X2' :|: z - 2 >= 0, X1 >= 0, X2' >= 0, 1 = X1, z - 2 = X2'
   activate(z) -{ 3 }-> 1 + X1' + X2' :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2, X1' >= 0, X2' >= 0, X1 = X1', X2 = X2'
   cons(z, z') -{ 1 }-> 1 + z + z' :|: z >= 0, z' >= 0
   from(z) -{ 1 }-> 1 + z :|: z >= 0
   from(z) -{ 2 }-> 1 + z + X2 :|: z >= 0, X2 >= 0, 1 + (1 + z) = X2
   length(z) -{ 2 }-> s(length1(Y)) :|: Y >= 0, z = 1 + X + Y, X >= 0
   length(z) -{ 33 + 37*X1' }-> s(length1(s14)) :|: s13 >= 0, s13 <= inf3, s14 >= 0, s14 <= s13 + X2' + 1, X2' >= 0, X1' >= 0, X >= 0, z = 1 + X + (1 + X1' + X2')
   length(z) -{ 33 + 37*X'' }-> s(length1(s2)) :|: s1 >= 0, s1 <= inf, s2 >= 0, s2 <= s1 + 1, z = 1 + X + (1 + X''), X >= 0, X'' >= 0
   length(z) -{ 34 + 37*X' }-> s(length1(s27)) :|: s26 >= 0, s26 <= inf8, s27 >= 0, s27 <= 2 * s26 + 3, z = 1 + X + (1 + X'), X >= 0, X' >= 0
   length(z) -{ 3 }-> s(length1(1)) :|: z - 2 >= 0
   length(z) -{ 1 }-> 0 :|: z = 1
   length(z) -{ 0 }-> 0 :|: z >= 0
   length1(z) -{ -3 + 37*z }-> length(s22) :|: s21 >= 0, s21 <= inf6, s22 >= 0, s22 <= 2 * s21 + 3, z - 1 >= 0
   length1(z) -{ -4 + 37*z }-> length(s4) :|: s3 >= 0, s3 <= inf', s4 >= 0, s4 <= s3 + 1, z - 1 >= 0
   length1(z) -{ 33 + 37*X1'' }-> length(s9) :|: s8 >= 0, s8 <= inf1, s9 >= 0, s9 <= s8 + X2'' + 1, X1'' >= 0, z = 1 + X1'' + X2'', X2'' >= 0
   length1(z) -{ 2 }-> length(z) :|: z >= 0
   length1(z) -{ 3 }-> length(1) :|: z = 1
   nil -{ 1 }-> 1 :|: 
   s(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {length1,length}
Previous analysis results are:
  nil: runtime: O(1) [1], size: O(1) [1]
  from: runtime: O(1) [2], size: O(n^1) [3 + 2*z]
  cons: runtime: O(1) [1], size: O(n^1) [1 + z + z']
  s: runtime: O(1) [1], size: O(n^1) [1 + z]
  activate: runtime: O(n^1) [30 + 37*z], size: EXP

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

(53) IntTrsBoundProof (UPPER BOUND(ID))

Computed SIZE bound using CoFloCo for: length1
after applying outer abstraction to obtain an ITS,
resulting in: INF with polynomial bound: ?

Computed SIZE bound using CoFloCo for: length
after applying outer abstraction to obtain an ITS,
resulting in: INF with polynomial bound: ?

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

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

   activate(z) -{ 4 }-> s :|: s >= 0, s <= X' + (1 + (1 + X')) + 1, z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 5 }-> s' :|: s' >= 0, s' <= X + (1 + (1 + X)) + 1, z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 4 }-> s'' :|: s'' >= 0, s'' <= 1 + 1, z = 1 + 1
   activate(z) -{ 34 + 37*X13 }-> s12 :|: s10 >= 0, s10 <= inf2, s11 >= 0, s11 <= s10 + X23 + 1, s12 >= 0, s12 <= s11 + X2 + 1, z = 1 + (1 + X13 + X23) + X2, X2 >= 0, X13 >= 0, X23 >= 0
   activate(z) -{ 34 + 37*X12 }-> s17 :|: s15 >= 0, s15 <= inf4, s16 >= 0, s16 <= s15 + X22 + 1, s17 >= 0, s17 <= s16 + 1, X12 >= 0, X22 >= 0, z = 1 + (1 + X12 + X22)
   activate(z) -{ 34 + 37*X10 }-> s20 :|: s18 >= 0, s18 <= inf5, s19 >= 0, s19 <= s18 + 1, s20 >= 0, s20 <= s19 + X2 + 1, X10 >= 0, z = 1 + (1 + X10) + X2, X2 >= 0
   activate(z) -{ -38 + 37*z }-> s25 :|: s23 >= 0, s23 <= inf7, s24 >= 0, s24 <= 2 * s23 + 3, s25 >= 0, s25 <= 2 * s24 + 3, z - 2 >= 0
   activate(z) -{ -39 + 37*z }-> s30 :|: s28 >= 0, s28 <= inf9, s29 >= 0, s29 <= s28 + 1, s30 >= 0, s30 <= 2 * s29 + 3, z - 2 >= 0
   activate(z) -{ -39 + 37*z }-> s33 :|: s31 >= 0, s31 <= inf10, s32 >= 0, s32 <= 2 * s31 + 3, s33 >= 0, s33 <= s32 + 1, z - 2 >= 0
   activate(z) -{ 35 + 37*X11 }-> s36 :|: s34 >= 0, s34 <= inf11, s35 >= 0, s35 <= s34 + X21 + 1, s36 >= 0, s36 <= 2 * s35 + 3, z = 1 + (1 + X11 + X21), X11 >= 0, X21 >= 0
   activate(z) -{ 35 + 37*X9 }-> s39 :|: s37 >= 0, s37 <= inf12, s38 >= 0, s38 <= 2 * s37 + 3, s39 >= 0, s39 <= s38 + X2 + 1, X9 >= 0, z = 1 + (1 + X9) + X2, X2 >= 0
   activate(z) -{ -40 + 37*z }-> s7 :|: s5 >= 0, s5 <= inf'', s6 >= 0, s6 <= s5 + 1, s7 >= 0, s7 <= s6 + 1, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 4 }-> 1 + X1 + X2' :|: z - 2 >= 0, X1 >= 0, X2' >= 0, 1 = X1, z - 2 = X2'
   activate(z) -{ 3 }-> 1 + X1' + X2' :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2, X1' >= 0, X2' >= 0, X1 = X1', X2 = X2'
   cons(z, z') -{ 1 }-> 1 + z + z' :|: z >= 0, z' >= 0
   from(z) -{ 1 }-> 1 + z :|: z >= 0
   from(z) -{ 2 }-> 1 + z + X2 :|: z >= 0, X2 >= 0, 1 + (1 + z) = X2
   length(z) -{ 2 }-> s(length1(Y)) :|: Y >= 0, z = 1 + X + Y, X >= 0
   length(z) -{ 33 + 37*X1' }-> s(length1(s14)) :|: s13 >= 0, s13 <= inf3, s14 >= 0, s14 <= s13 + X2' + 1, X2' >= 0, X1' >= 0, X >= 0, z = 1 + X + (1 + X1' + X2')
   length(z) -{ 33 + 37*X'' }-> s(length1(s2)) :|: s1 >= 0, s1 <= inf, s2 >= 0, s2 <= s1 + 1, z = 1 + X + (1 + X''), X >= 0, X'' >= 0
   length(z) -{ 34 + 37*X' }-> s(length1(s27)) :|: s26 >= 0, s26 <= inf8, s27 >= 0, s27 <= 2 * s26 + 3, z = 1 + X + (1 + X'), X >= 0, X' >= 0
   length(z) -{ 3 }-> s(length1(1)) :|: z - 2 >= 0
   length(z) -{ 1 }-> 0 :|: z = 1
   length(z) -{ 0 }-> 0 :|: z >= 0
   length1(z) -{ -3 + 37*z }-> length(s22) :|: s21 >= 0, s21 <= inf6, s22 >= 0, s22 <= 2 * s21 + 3, z - 1 >= 0
   length1(z) -{ -4 + 37*z }-> length(s4) :|: s3 >= 0, s3 <= inf', s4 >= 0, s4 <= s3 + 1, z - 1 >= 0
   length1(z) -{ 33 + 37*X1'' }-> length(s9) :|: s8 >= 0, s8 <= inf1, s9 >= 0, s9 <= s8 + X2'' + 1, X1'' >= 0, z = 1 + X1'' + X2'', X2'' >= 0
   length1(z) -{ 2 }-> length(z) :|: z >= 0
   length1(z) -{ 3 }-> length(1) :|: z = 1
   nil -{ 1 }-> 1 :|: 
   s(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {length1,length}
Previous analysis results are:
  nil: runtime: O(1) [1], size: O(1) [1]
  from: runtime: O(1) [2], size: O(n^1) [3 + 2*z]
  cons: runtime: O(1) [1], size: O(n^1) [1 + z + z']
  s: runtime: O(1) [1], size: O(n^1) [1 + z]
  activate: runtime: O(n^1) [30 + 37*z], size: EXP
  length1: runtime: ?, size: INF
  length: runtime: ?, size: INF

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

(55) IntTrsBoundProof (UPPER BOUND(ID))

Computed RUNTIME bound using CoFloCo for: length1
after applying outer abstraction to obtain an ITS,
resulting in: INF with polynomial bound: ?

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

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

   activate(z) -{ 4 }-> s :|: s >= 0, s <= X' + (1 + (1 + X')) + 1, z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 5 }-> s' :|: s' >= 0, s' <= X + (1 + (1 + X)) + 1, z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 4 }-> s'' :|: s'' >= 0, s'' <= 1 + 1, z = 1 + 1
   activate(z) -{ 34 + 37*X13 }-> s12 :|: s10 >= 0, s10 <= inf2, s11 >= 0, s11 <= s10 + X23 + 1, s12 >= 0, s12 <= s11 + X2 + 1, z = 1 + (1 + X13 + X23) + X2, X2 >= 0, X13 >= 0, X23 >= 0
   activate(z) -{ 34 + 37*X12 }-> s17 :|: s15 >= 0, s15 <= inf4, s16 >= 0, s16 <= s15 + X22 + 1, s17 >= 0, s17 <= s16 + 1, X12 >= 0, X22 >= 0, z = 1 + (1 + X12 + X22)
   activate(z) -{ 34 + 37*X10 }-> s20 :|: s18 >= 0, s18 <= inf5, s19 >= 0, s19 <= s18 + 1, s20 >= 0, s20 <= s19 + X2 + 1, X10 >= 0, z = 1 + (1 + X10) + X2, X2 >= 0
   activate(z) -{ -38 + 37*z }-> s25 :|: s23 >= 0, s23 <= inf7, s24 >= 0, s24 <= 2 * s23 + 3, s25 >= 0, s25 <= 2 * s24 + 3, z - 2 >= 0
   activate(z) -{ -39 + 37*z }-> s30 :|: s28 >= 0, s28 <= inf9, s29 >= 0, s29 <= s28 + 1, s30 >= 0, s30 <= 2 * s29 + 3, z - 2 >= 0
   activate(z) -{ -39 + 37*z }-> s33 :|: s31 >= 0, s31 <= inf10, s32 >= 0, s32 <= 2 * s31 + 3, s33 >= 0, s33 <= s32 + 1, z - 2 >= 0
   activate(z) -{ 35 + 37*X11 }-> s36 :|: s34 >= 0, s34 <= inf11, s35 >= 0, s35 <= s34 + X21 + 1, s36 >= 0, s36 <= 2 * s35 + 3, z = 1 + (1 + X11 + X21), X11 >= 0, X21 >= 0
   activate(z) -{ 35 + 37*X9 }-> s39 :|: s37 >= 0, s37 <= inf12, s38 >= 0, s38 <= 2 * s37 + 3, s39 >= 0, s39 <= s38 + X2 + 1, X9 >= 0, z = 1 + (1 + X9) + X2, X2 >= 0
   activate(z) -{ -40 + 37*z }-> s7 :|: s5 >= 0, s5 <= inf'', s6 >= 0, s6 <= s5 + 1, s7 >= 0, s7 <= s6 + 1, z - 2 >= 0
   activate(z) -{ 1 }-> z :|: z >= 0
   activate(z) -{ 2 }-> 1 :|: z = 1
   activate(z) -{ 4 }-> 1 + X :|: z = 1 + 1, X >= 0, 1 = X
   activate(z) -{ 3 }-> 1 + X' :|: z - 1 >= 0, X' >= 0, z - 1 = X'
   activate(z) -{ 4 }-> 1 + X1 + X2' :|: z - 2 >= 0, X1 >= 0, X2' >= 0, 1 = X1, z - 2 = X2'
   activate(z) -{ 3 }-> 1 + X1' + X2' :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2, X1' >= 0, X2' >= 0, X1 = X1', X2 = X2'
   cons(z, z') -{ 1 }-> 1 + z + z' :|: z >= 0, z' >= 0
   from(z) -{ 1 }-> 1 + z :|: z >= 0
   from(z) -{ 2 }-> 1 + z + X2 :|: z >= 0, X2 >= 0, 1 + (1 + z) = X2
   length(z) -{ 2 }-> s(length1(Y)) :|: Y >= 0, z = 1 + X + Y, X >= 0
   length(z) -{ 33 + 37*X1' }-> s(length1(s14)) :|: s13 >= 0, s13 <= inf3, s14 >= 0, s14 <= s13 + X2' + 1, X2' >= 0, X1' >= 0, X >= 0, z = 1 + X + (1 + X1' + X2')
   length(z) -{ 33 + 37*X'' }-> s(length1(s2)) :|: s1 >= 0, s1 <= inf, s2 >= 0, s2 <= s1 + 1, z = 1 + X + (1 + X''), X >= 0, X'' >= 0
   length(z) -{ 34 + 37*X' }-> s(length1(s27)) :|: s26 >= 0, s26 <= inf8, s27 >= 0, s27 <= 2 * s26 + 3, z = 1 + X + (1 + X'), X >= 0, X' >= 0
   length(z) -{ 3 }-> s(length1(1)) :|: z - 2 >= 0
   length(z) -{ 1 }-> 0 :|: z = 1
   length(z) -{ 0 }-> 0 :|: z >= 0
   length1(z) -{ -3 + 37*z }-> length(s22) :|: s21 >= 0, s21 <= inf6, s22 >= 0, s22 <= 2 * s21 + 3, z - 1 >= 0
   length1(z) -{ -4 + 37*z }-> length(s4) :|: s3 >= 0, s3 <= inf', s4 >= 0, s4 <= s3 + 1, z - 1 >= 0
   length1(z) -{ 33 + 37*X1'' }-> length(s9) :|: s8 >= 0, s8 <= inf1, s9 >= 0, s9 <= s8 + X2'' + 1, X1'' >= 0, z = 1 + X1'' + X2'', X2'' >= 0
   length1(z) -{ 2 }-> length(z) :|: z >= 0
   length1(z) -{ 3 }-> length(1) :|: z = 1
   nil -{ 1 }-> 1 :|: 
   s(z) -{ 1 }-> 1 + z :|: z >= 0

Function symbols to be analyzed: {length1,length}
Previous analysis results are:
  nil: runtime: O(1) [1], size: O(1) [1]
  from: runtime: O(1) [2], size: O(n^1) [3 + 2*z]
  cons: runtime: O(1) [1], size: O(n^1) [1 + z + z']
  s: runtime: O(1) [1], size: O(n^1) [1 + z]
  activate: runtime: O(n^1) [30 + 37*z], size: EXP
  length1: runtime: INF, size: INF
  length: runtime: ?, size: INF

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

(57) 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:

   length(v0) -> null_length [0]

And the following fresh constants:    null_length

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

(58)
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:

   from(X) -> cons(X, n__from(n__s(X))) [1]
   length(n__nil) -> 0 [1]
   length(n__cons(X, Y)) -> s(length1(activate(Y))) [1]
   length1(X) -> length(activate(X)) [1]
   from(X) -> n__from(X) [1]
   s(X) -> n__s(X) [1]
   nil -> n__nil [1]
   cons(X1, X2) -> n__cons(X1, X2) [1]
   activate(n__from(X)) -> from(activate(X)) [1]
   activate(n__s(X)) -> s(activate(X)) [1]
   activate(n__nil) -> nil [1]
   activate(n__cons(X1, X2)) -> cons(activate(X1), X2) [1]
   activate(X) -> X [1]
   length(v0) -> null_length [0]

The TRS has the following type information:
from :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
cons :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
n__from :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
n__s :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
length :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
n__nil :: n__s:n__from:n__nil:0:n__cons:null_length
0 :: n__s:n__from:n__nil:0:n__cons:null_length
n__cons :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
s :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
length1 :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
activate :: n__s:n__from:n__nil:0:n__cons:null_length -> n__s:n__from:n__nil:0:n__cons:null_length
nil :: n__s:n__from:n__nil:0:n__cons:null_length
null_length :: n__s:n__from:n__nil:0:n__cons:null_length

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

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

   n__nil => 1
   0 => 0
   null_length => 0

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

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

   activate(z) -{ 1 }-> X :|: X >= 0, z = X
   activate(z) -{ 1 }-> s(activate(X)) :|: z = 1 + X, X >= 0
   activate(z) -{ 1 }-> nil :|: z = 1
   activate(z) -{ 1 }-> from(activate(X)) :|: z = 1 + X, X >= 0
   activate(z) -{ 1 }-> cons(activate(X1), X2) :|: X1 >= 0, X2 >= 0, z = 1 + X1 + X2
   cons(z, z') -{ 1 }-> 1 + X1 + X2 :|: X1 >= 0, X2 >= 0, z = X1, z' = X2
   from(z) -{ 1 }-> cons(X, 1 + (1 + X)) :|: X >= 0, z = X
   from(z) -{ 1 }-> 1 + X :|: X >= 0, z = X
   length(z) -{ 1 }-> s(length1(activate(Y))) :|: Y >= 0, z = 1 + X + Y, X >= 0
   length(z) -{ 1 }-> 0 :|: z = 1
   length(z) -{ 0 }-> 0 :|: v0 >= 0, z = v0
   length1(z) -{ 1 }-> length(activate(X)) :|: X >= 0, z = X
   nil -{ 1 }-> 1 :|: 
   s(z) -{ 1 }-> 1 + X :|: X >= 0, z = X

Only complete derivations are relevant for the runtime complexity.

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

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

(62)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   length(n__nil) -> 0
   length(n__cons(z0, z1)) -> s(length1(activate(z1)))
   length1(z0) -> length(activate(z0))
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
Tuples:
   FROM(z0) -> c(CONS(z0, n__from(n__s(z0))))
   FROM(z0) -> c1
   LENGTH(n__nil) -> c2
   LENGTH(n__cons(z0, z1)) -> c3(S(length1(activate(z1))), LENGTH1(activate(z1)), ACTIVATE(z1))
   LENGTH1(z0) -> c4(LENGTH(activate(z0)), ACTIVATE(z0))
   S(z0) -> c5
   NIL -> c6
   CONS(z0, z1) -> c7
   ACTIVATE(n__from(z0)) -> c8(FROM(activate(z0)), ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(S(activate(z0)), ACTIVATE(z0))
   ACTIVATE(n__nil) -> c10(NIL)
   ACTIVATE(n__cons(z0, z1)) -> c11(CONS(activate(z0), z1), ACTIVATE(z0))
   ACTIVATE(z0) -> c12
S tuples:
   FROM(z0) -> c(CONS(z0, n__from(n__s(z0))))
   FROM(z0) -> c1
   LENGTH(n__nil) -> c2
   LENGTH(n__cons(z0, z1)) -> c3(S(length1(activate(z1))), LENGTH1(activate(z1)), ACTIVATE(z1))
   LENGTH1(z0) -> c4(LENGTH(activate(z0)), ACTIVATE(z0))
   S(z0) -> c5
   NIL -> c6
   CONS(z0, z1) -> c7
   ACTIVATE(n__from(z0)) -> c8(FROM(activate(z0)), ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(S(activate(z0)), ACTIVATE(z0))
   ACTIVATE(n__nil) -> c10(NIL)
   ACTIVATE(n__cons(z0, z1)) -> c11(CONS(activate(z0), z1), ACTIVATE(z0))
   ACTIVATE(z0) -> c12
K tuples:none
Defined Rule Symbols:   from_1, length_1, length1_1, s_1, nil, cons_2, activate_1

Defined Pair Symbols:   FROM_1, LENGTH_1, LENGTH1_1, S_1, NIL, CONS_2, ACTIVATE_1

Compound Symbols:   c_1, c1, c2, c3_3, c4_2, c5, c6, c7, c8_2, c9_2, c10_1, c11_2, c12


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

(63) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 8 trailing nodes:
   NIL -> c6
   S(z0) -> c5
   ACTIVATE(n__nil) -> c10(NIL)
   LENGTH(n__nil) -> c2
   CONS(z0, z1) -> c7
   FROM(z0) -> c1
   ACTIVATE(z0) -> c12
   FROM(z0) -> c(CONS(z0, n__from(n__s(z0))))

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

(64)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   length(n__nil) -> 0
   length(n__cons(z0, z1)) -> s(length1(activate(z1)))
   length1(z0) -> length(activate(z0))
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
Tuples:
   LENGTH(n__cons(z0, z1)) -> c3(S(length1(activate(z1))), LENGTH1(activate(z1)), ACTIVATE(z1))
   LENGTH1(z0) -> c4(LENGTH(activate(z0)), ACTIVATE(z0))
   ACTIVATE(n__from(z0)) -> c8(FROM(activate(z0)), ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(S(activate(z0)), ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(CONS(activate(z0), z1), ACTIVATE(z0))
S tuples:
   LENGTH(n__cons(z0, z1)) -> c3(S(length1(activate(z1))), LENGTH1(activate(z1)), ACTIVATE(z1))
   LENGTH1(z0) -> c4(LENGTH(activate(z0)), ACTIVATE(z0))
   ACTIVATE(n__from(z0)) -> c8(FROM(activate(z0)), ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(S(activate(z0)), ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(CONS(activate(z0), z1), ACTIVATE(z0))
K tuples:none
Defined Rule Symbols:   from_1, length_1, length1_1, s_1, nil, cons_2, activate_1

Defined Pair Symbols:   LENGTH_1, LENGTH1_1, ACTIVATE_1

Compound Symbols:   c3_3, c4_2, c8_2, c9_2, c11_2


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

(65) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 4 trailing tuple parts
----------------------------------------

(66)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   length(n__nil) -> 0
   length(n__cons(z0, z1)) -> s(length1(activate(z1)))
   length1(z0) -> length(activate(z0))
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
Tuples:
   LENGTH1(z0) -> c4(LENGTH(activate(z0)), ACTIVATE(z0))
   LENGTH(n__cons(z0, z1)) -> c3(LENGTH1(activate(z1)), ACTIVATE(z1))
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
S tuples:
   LENGTH1(z0) -> c4(LENGTH(activate(z0)), ACTIVATE(z0))
   LENGTH(n__cons(z0, z1)) -> c3(LENGTH1(activate(z1)), ACTIVATE(z1))
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
K tuples:none
Defined Rule Symbols:   from_1, length_1, length1_1, s_1, nil, cons_2, activate_1

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c3_2, c8_1, c9_1, c11_1


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

(67) CdtUsableRulesProof (BOTH BOUNDS(ID, ID))
The following rules are not usable and were removed:
   length(n__nil) -> 0
   length(n__cons(z0, z1)) -> s(length1(activate(z1)))
   length1(z0) -> length(activate(z0))

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

(68)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(z0) -> c4(LENGTH(activate(z0)), ACTIVATE(z0))
   LENGTH(n__cons(z0, z1)) -> c3(LENGTH1(activate(z1)), ACTIVATE(z1))
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
S tuples:
   LENGTH1(z0) -> c4(LENGTH(activate(z0)), ACTIVATE(z0))
   LENGTH(n__cons(z0, z1)) -> c3(LENGTH1(activate(z1)), ACTIVATE(z1))
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
K tuples:none
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c3_2, c8_1, c9_1, c11_1


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

(69) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace LENGTH1(z0) -> c4(LENGTH(activate(z0)), ACTIVATE(z0)) by 
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH1(n__nil) -> c4(LENGTH(nil), ACTIVATE(n__nil))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))

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

(70)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH(n__cons(z0, z1)) -> c3(LENGTH1(activate(z1)), ACTIVATE(z1))
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH1(n__nil) -> c4(LENGTH(nil), ACTIVATE(n__nil))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
S tuples:
   LENGTH(n__cons(z0, z1)) -> c3(LENGTH1(activate(z1)), ACTIVATE(z1))
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH1(n__nil) -> c4(LENGTH(nil), ACTIVATE(n__nil))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
K tuples:none
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH_1, ACTIVATE_1, LENGTH1_1

Compound Symbols:   c3_2, c8_1, c9_1, c11_1, c4_2


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

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

(72)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH(n__cons(z0, z1)) -> c3(LENGTH1(activate(z1)), ACTIVATE(z1))
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH1(n__nil) -> c4(LENGTH(nil))
S tuples:
   LENGTH(n__cons(z0, z1)) -> c3(LENGTH1(activate(z1)), ACTIVATE(z1))
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH1(n__nil) -> c4(LENGTH(nil))
K tuples:none
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH_1, ACTIVATE_1, LENGTH1_1

Compound Symbols:   c3_2, c8_1, c9_1, c11_1, c4_2, c4_1


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

(73) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace LENGTH(n__cons(z0, z1)) -> c3(LENGTH1(activate(z1)), ACTIVATE(z1)) by 
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil), ACTIVATE(n__nil))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))

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

(74)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH1(n__nil) -> c4(LENGTH(nil))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil), ACTIVATE(n__nil))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
S tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH1(n__nil) -> c4(LENGTH(nil))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil), ACTIVATE(n__nil))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
K tuples:none
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c8_1, c9_1, c11_1, c4_2, c4_1, c3_2


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

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

(76)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH1(n__nil) -> c4(LENGTH(nil))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
S tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH1(n__nil) -> c4(LENGTH(nil))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
K tuples:none
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c8_1, c9_1, c11_1, c4_2, c4_1, c3_2, c3_1


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

(77) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace LENGTH1(n__from(z0)) -> c4(LENGTH(from(activate(z0))), ACTIVATE(n__from(z0))) by 
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(x0)) -> c4(LENGTH(n__from(activate(x0))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))

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

(78)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH1(n__nil) -> c4(LENGTH(nil))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(x0)) -> c4(LENGTH(n__from(activate(x0))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
S tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH1(n__nil) -> c4(LENGTH(nil))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(x0)) -> c4(LENGTH(n__from(activate(x0))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
K tuples:none
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c8_1, c9_1, c11_1, c4_2, c4_1, c3_2, c3_1


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

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

(80)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH1(n__nil) -> c4(LENGTH(nil))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
S tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH1(n__nil) -> c4(LENGTH(nil))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
K tuples:none
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c8_1, c9_1, c11_1, c4_2, c4_1, c3_2, c3_1


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

(81) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
We considered the (Usable) Rules:none
And the Tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH1(n__nil) -> c4(LENGTH(nil))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(ACTIVATE(x_1)) = 0
   POL(LENGTH(x_1)) = [1]
   POL(LENGTH1(x_1)) = [1]
   POL(activate(x_1)) = 0
   POL(c11(x_1)) = x_1
   POL(c3(x_1)) = x_1
   POL(c3(x_1, x_2)) = x_1 + x_2
   POL(c4(x_1)) = x_1
   POL(c4(x_1, x_2)) = x_1 + x_2
   POL(c8(x_1)) = x_1
   POL(c9(x_1)) = x_1
   POL(cons(x_1, x_2)) = 0
   POL(from(x_1)) = 0
   POL(n__cons(x_1, x_2)) = x_1
   POL(n__from(x_1)) = 0
   POL(n__nil) = 0
   POL(n__s(x_1)) = 0
   POL(nil) = 0
   POL(s(x_1)) = 0

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

(82)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH1(n__nil) -> c4(LENGTH(nil))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
S tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH1(n__nil) -> c4(LENGTH(nil))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c8_1, c9_1, c11_1, c4_2, c4_1, c3_2, c3_1


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

(83) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace LENGTH1(n__s(z0)) -> c4(LENGTH(s(activate(z0))), ACTIVATE(n__s(z0))) by 
   LENGTH1(n__s(x0)) -> c4(LENGTH(n__s(activate(x0))), ACTIVATE(n__s(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(z0)), ACTIVATE(n__s(z0)))

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

(84)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH1(n__nil) -> c4(LENGTH(nil))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(LENGTH(n__s(activate(x0))), ACTIVATE(n__s(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(z0)), ACTIVATE(n__s(z0)))
S tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH1(n__nil) -> c4(LENGTH(nil))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(x0)) -> c4(LENGTH(n__s(activate(x0))), ACTIVATE(n__s(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(z0)), ACTIVATE(n__s(z0)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c8_1, c9_1, c11_1, c4_2, c4_1, c3_2, c3_1


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

(85) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(86)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH1(n__nil) -> c4(LENGTH(nil))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
S tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH1(n__nil) -> c4(LENGTH(nil))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c8_1, c9_1, c11_1, c4_2, c4_1, c3_2, c3_1


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

(87) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
We considered the (Usable) Rules:none
And the Tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH1(n__nil) -> c4(LENGTH(nil))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(ACTIVATE(x_1)) = 0
   POL(LENGTH(x_1)) = [1]
   POL(LENGTH1(x_1)) = [1]
   POL(activate(x_1)) = 0
   POL(c11(x_1)) = x_1
   POL(c3(x_1)) = x_1
   POL(c3(x_1, x_2)) = x_1 + x_2
   POL(c4(x_1)) = x_1
   POL(c4(x_1, x_2)) = x_1 + x_2
   POL(c8(x_1)) = x_1
   POL(c9(x_1)) = x_1
   POL(cons(x_1, x_2)) = 0
   POL(from(x_1)) = 0
   POL(n__cons(x_1, x_2)) = x_1
   POL(n__from(x_1)) = 0
   POL(n__nil) = 0
   POL(n__s(x_1)) = 0
   POL(nil) = 0
   POL(s(x_1)) = 0

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

(88)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH1(n__nil) -> c4(LENGTH(nil))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
S tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH1(n__nil) -> c4(LENGTH(nil))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(z0)), ACTIVATE(n__s(z0)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c8_1, c9_1, c11_1, c4_2, c4_1, c3_2, c3_1


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

(89) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1))) by 
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))

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

(90)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH1(n__nil) -> c4(LENGTH(nil))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
S tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH1(n__nil) -> c4(LENGTH(nil))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c8_1, c9_1, c11_1, c4_2, c4_1, c3_2, c3_1


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

(91) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace LENGTH1(n__nil) -> c4(LENGTH(nil)) by 
   LENGTH1(n__nil) -> c4(LENGTH(n__nil))

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

(92)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH1(n__nil) -> c4(LENGTH(n__nil))
S tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH1(n__nil) -> c4(LENGTH(n__nil))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c8_1, c9_1, c11_1, c4_2, c3_2, c3_1, c4_1


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

(93) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   LENGTH1(n__nil) -> c4(LENGTH(n__nil))

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

(94)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
S tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c8_1, c9_1, c11_1, c4_2, c3_2, c3_1, c4_1


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

(95) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(activate(z0))), ACTIVATE(n__from(z0))) by 
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))

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

(96)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
S tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c8_1, c9_1, c11_1, c4_2, c3_2, c3_1, c4_1


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

(97) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(activate(z0))), ACTIVATE(n__s(z0))) by 
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))

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

(98)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
S tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c8_1, c9_1, c11_1, c4_2, c3_2, c3_1, c4_1


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

(99) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace LENGTH(n__cons(x0, n__cons(z0, z1))) -> c3(LENGTH1(cons(activate(z0), z1)), ACTIVATE(n__cons(z0, z1))) by 
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))

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

(100)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
S tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c8_1, c9_1, c11_1, c4_2, c3_2, c3_1, c4_1


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

(101) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(nil)) by 
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))

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

(102)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
S tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(z0)) -> c4(LENGTH(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c8_1, c9_1, c11_1, c4_2, c3_2, c4_1, c3_1


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

(103) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace LENGTH1(n__s(z0)) -> c4(LENGTH(s(z0)), ACTIVATE(n__s(z0))) by 
   LENGTH1(n__s(z0)) -> c4(LENGTH(n__s(z0)), ACTIVATE(n__s(z0)))

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

(104)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   LENGTH1(n__s(z0)) -> c4(LENGTH(n__s(z0)), ACTIVATE(n__s(z0)))
S tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   LENGTH1(n__s(z0)) -> c4(LENGTH(n__s(z0)), ACTIVATE(n__s(z0)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c8_1, c9_1, c11_1, c4_2, c3_2, c4_1, c3_1


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

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

(106)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
S tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   LENGTH1(n__s(z0)) -> c4(ACTIVATE(n__s(z0)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c8_1, c9_1, c11_1, c4_2, c3_2, c4_1, c3_1


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

(107) CdtKnowledgeProof (BOTH BOUNDS(ID, ID))
The following tuples could be moved from S to K by knowledge propagation:
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__s(z0)) -> c4(ACTIVATE(n__s(z0)))

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

(108)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
S tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c8_1, c9_1, c11_1, c4_2, c3_2, c4_1, c3_1


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

(109) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(nil)), ACTIVATE(n__from(n__nil))) by LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)), ACTIVATE(n__from(n__nil)))
----------------------------------------

(110)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)), ACTIVATE(n__from(n__nil)))
S tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)), ACTIVATE(n__from(n__nil)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c8_1, c9_1, c11_1, c4_2, c3_2, c4_1, c3_1


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

(111) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace LENGTH1(n__s(n__nil)) -> c4(LENGTH(s(nil)), ACTIVATE(n__s(n__nil))) by LENGTH1(n__s(n__nil)) -> c4(LENGTH(n__s(nil)), ACTIVATE(n__s(n__nil)))
----------------------------------------

(112)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(n__s(nil)), ACTIVATE(n__s(n__nil)))
S tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__s(n__nil)) -> c4(LENGTH(n__s(nil)), ACTIVATE(n__s(n__nil)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c8_1, c9_1, c11_1, c4_2, c3_2, c4_1, c3_1


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

(113) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(114)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__s(n__nil)) -> c4(ACTIVATE(n__s(n__nil)))
S tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__s(n__nil)) -> c4(ACTIVATE(n__s(n__nil)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c8_1, c9_1, c11_1, c4_2, c3_2, c4_1, c3_1


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

(115) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   LENGTH1(n__s(n__nil)) -> c4(ACTIVATE(n__s(n__nil)))
We considered the (Usable) Rules:none
And the Tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__s(n__nil)) -> c4(ACTIVATE(n__s(n__nil)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(ACTIVATE(x_1)) = 0
   POL(LENGTH(x_1)) = [1]
   POL(LENGTH1(x_1)) = [1]
   POL(activate(x_1)) = 0
   POL(c11(x_1)) = x_1
   POL(c3(x_1)) = x_1
   POL(c3(x_1, x_2)) = x_1 + x_2
   POL(c4(x_1)) = x_1
   POL(c4(x_1, x_2)) = x_1 + x_2
   POL(c8(x_1)) = x_1
   POL(c9(x_1)) = x_1
   POL(cons(x_1, x_2)) = 0
   POL(from(x_1)) = 0
   POL(n__cons(x_1, x_2)) = 0
   POL(n__from(x_1)) = 0
   POL(n__nil) = 0
   POL(n__s(x_1)) = 0
   POL(nil) = 0
   POL(s(x_1)) = 0

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

(116)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__s(n__nil)) -> c4(ACTIVATE(n__s(n__nil)))
S tuples:
   ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0))
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)), ACTIVATE(n__from(n__nil)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__s(n__nil)) -> c4(ACTIVATE(n__s(n__nil)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c8_1, c9_1, c11_1, c4_2, c3_2, c4_1, c3_1


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

(117) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace ACTIVATE(n__from(z0)) -> c8(ACTIVATE(z0)) by 
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))

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

(118)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)), ACTIVATE(n__from(n__nil)))
   LENGTH1(n__s(n__nil)) -> c4(ACTIVATE(n__s(n__nil)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
S tuples:
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)), ACTIVATE(n__from(n__nil)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__s(n__nil)) -> c4(ACTIVATE(n__s(n__nil)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c9_1, c11_1, c4_2, c3_2, c4_1, c3_1, c8_1


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

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

(120)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   LENGTH1(n__s(n__nil)) -> c4(ACTIVATE(n__s(n__nil)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
S tuples:
   ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0))
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__s(n__nil)) -> c4(ACTIVATE(n__s(n__nil)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c9_1, c11_1, c4_2, c3_2, c4_1, c3_1, c8_1


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

(121) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace ACTIVATE(n__s(z0)) -> c9(ACTIVATE(z0)) by 
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))

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

(122)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   LENGTH1(n__s(n__nil)) -> c4(ACTIVATE(n__s(n__nil)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
S tuples:
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__s(n__nil)) -> c4(ACTIVATE(n__s(n__nil)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c11_1, c4_2, c3_2, c4_1, c3_1, c8_1, c9_1


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

(123) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   LENGTH1(n__s(n__nil)) -> c4(ACTIVATE(n__s(n__nil)))

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

(124)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
S tuples:
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)), ACTIVATE(n__s(n__nil)))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c11_1, c4_2, c3_2, c4_1, c3_1, c8_1, c9_1


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

(125) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing tuple parts
----------------------------------------

(126)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
S tuples:
   ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0))
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   ACTIVATE_1, LENGTH1_1, LENGTH_1

Compound Symbols:   c11_1, c4_2, c3_2, c4_1, c3_1, c8_1, c9_1


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

(127) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace ACTIVATE(n__cons(z0, z1)) -> c11(ACTIVATE(z0)) by 
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))

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

(128)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
S tuples:
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)), ACTIVATE(n__cons(n__nil, x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)), ACTIVATE(n__cons(n__nil, x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c3_2, c4_1, c3_1, c8_1, c9_1, c11_1


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

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

(130)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
S tuples:
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c3_2, c4_1, c3_1, c8_1, c9_1, c11_1


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

(131) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace LENGTH1(n__cons(z0, x1)) -> c4(LENGTH(cons(z0, x1)), ACTIVATE(n__cons(z0, x1))) by LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
----------------------------------------

(132)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
S tuples:
   LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0))
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c3_2, c4_1, c3_1, c8_1, c9_1, c11_1


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

(133) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace LENGTH1(z0) -> c4(LENGTH(z0), ACTIVATE(z0)) by 
   LENGTH1(n__cons(y0, y1)) -> c4(LENGTH(n__cons(y0, y1)), ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__from(n__from(y0))) -> c4(LENGTH(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(LENGTH(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(LENGTH(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__s(n__s(y0))) -> c4(LENGTH(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(LENGTH(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(LENGTH(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(LENGTH(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(LENGTH(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))

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

(134)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__from(n__from(y0))) -> c4(LENGTH(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(LENGTH(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(LENGTH(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__s(n__s(y0))) -> c4(LENGTH(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(LENGTH(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(LENGTH(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(LENGTH(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(LENGTH(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
S tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__from(n__from(y0))) -> c4(LENGTH(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(LENGTH(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(LENGTH(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__s(n__s(y0))) -> c4(LENGTH(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(LENGTH(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(LENGTH(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(LENGTH(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(LENGTH(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH_1, LENGTH1_1, ACTIVATE_1

Compound Symbols:   c3_2, c4_2, c4_1, c3_1, c8_1, c9_1, c11_1


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

(135) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   LENGTH(n__cons(x0, n__nil)) -> c3(LENGTH1(n__nil))

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

(136)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__from(n__from(y0))) -> c4(LENGTH(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(LENGTH(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(LENGTH(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__s(n__s(y0))) -> c4(LENGTH(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(LENGTH(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(LENGTH(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(LENGTH(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(LENGTH(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
S tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__from(n__from(y0))) -> c4(LENGTH(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(LENGTH(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(LENGTH(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__s(n__s(y0))) -> c4(LENGTH(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(LENGTH(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(LENGTH(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(LENGTH(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(LENGTH(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH_1, LENGTH1_1, ACTIVATE_1

Compound Symbols:   c3_2, c4_2, c4_1, c8_1, c3_1, c9_1, c11_1


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

(137) CdtRhsSimplificationProcessorProof (BOTH BOUNDS(ID, ID))
Removed 8 trailing tuple parts
----------------------------------------

(138)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
S tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH_1, LENGTH1_1, ACTIVATE_1

Compound Symbols:   c3_2, c4_2, c4_1, c8_1, c3_1, c9_1, c11_1


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

(139) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
We considered the (Usable) Rules:none
And the Tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(ACTIVATE(x_1)) = 0
   POL(LENGTH(x_1)) = [1]
   POL(LENGTH1(x_1)) = [1]
   POL(activate(x_1)) = 0
   POL(c11(x_1)) = x_1
   POL(c3(x_1)) = x_1
   POL(c3(x_1, x_2)) = x_1 + x_2
   POL(c4(x_1)) = x_1
   POL(c4(x_1, x_2)) = x_1 + x_2
   POL(c8(x_1)) = x_1
   POL(c9(x_1)) = x_1
   POL(cons(x_1, x_2)) = 0
   POL(from(x_1)) = 0
   POL(n__cons(x_1, x_2)) = 0
   POL(n__from(x_1)) = 0
   POL(n__nil) = 0
   POL(n__s(x_1)) = 0
   POL(nil) = 0
   POL(s(x_1)) = 0

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

(140)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
S tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH_1, LENGTH1_1, ACTIVATE_1

Compound Symbols:   c3_2, c4_2, c4_1, c8_1, c3_1, c9_1, c11_1


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

(141) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
We considered the (Usable) Rules:
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   cons(z0, z1) -> n__cons(z0, z1)
And the Tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(ACTIVATE(x_1)) = 0
   POL(LENGTH(x_1)) = x_1
   POL(LENGTH1(x_1)) = [1]
   POL(activate(x_1)) = 0
   POL(c11(x_1)) = x_1
   POL(c3(x_1)) = x_1
   POL(c3(x_1, x_2)) = x_1 + x_2
   POL(c4(x_1)) = x_1
   POL(c4(x_1, x_2)) = x_1 + x_2
   POL(c8(x_1)) = x_1
   POL(c9(x_1)) = x_1
   POL(cons(x_1, x_2)) = [1]
   POL(from(x_1)) = [1]
   POL(n__cons(x_1, x_2)) = [1]
   POL(n__from(x_1)) = 0
   POL(n__nil) = 0
   POL(n__s(x_1)) = 0
   POL(nil) = 0
   POL(s(x_1)) = 0

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

(142)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
S tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH_1, LENGTH1_1, ACTIVATE_1

Compound Symbols:   c3_2, c4_2, c4_1, c8_1, c3_1, c9_1, c11_1


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

(143) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace LENGTH(n__cons(x0, n__s(z0))) -> c3(LENGTH1(s(z0)), ACTIVATE(n__s(z0))) by LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
----------------------------------------

(144)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
S tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH_1, LENGTH1_1, ACTIVATE_1

Compound Symbols:   c3_2, c4_2, c4_1, c8_1, c3_1, c9_1, c11_1


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

(145) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace LENGTH(n__cons(x0, n__cons(z0, x2))) -> c3(LENGTH1(cons(z0, x2)), ACTIVATE(n__cons(z0, x2))) by LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
----------------------------------------

(146)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
S tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH_1, LENGTH1_1, ACTIVATE_1

Compound Symbols:   c3_2, c4_2, c4_1, c8_1, c3_1, c9_1, c11_1


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

(147) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace LENGTH(n__cons(x0, n__from(n__nil))) -> c3(LENGTH1(from(nil))) by LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
----------------------------------------

(148)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
S tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH_1, LENGTH1_1, ACTIVATE_1

Compound Symbols:   c3_2, c4_2, c4_1, c8_1, c9_1, c3_1, c11_1


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

(149) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(s(nil))) by LENGTH(n__cons(z0, n__s(n__nil))) -> c3(LENGTH1(n__s(nil)))
----------------------------------------

(150)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH(n__cons(z0, n__s(n__nil))) -> c3(LENGTH1(n__s(nil)))
S tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH(n__cons(z0, n__s(n__nil))) -> c3(LENGTH1(n__s(nil)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH_1, LENGTH1_1, ACTIVATE_1

Compound Symbols:   c3_2, c4_2, c4_1, c8_1, c9_1, c11_1, c3_1


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

(151) CdtNarrowingProof (BOTH BOUNDS(ID, ID))
Use narrowing to replace LENGTH(n__cons(z0, n__s(n__nil))) -> c3(LENGTH1(n__s(nil))) by 
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))

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

(152)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
S tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1)))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH_1, LENGTH1_1, ACTIVATE_1

Compound Symbols:   c3_2, c4_2, c4_1, c8_1, c9_1, c11_1, c3_1


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

(153) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace LENGTH1(n__cons(n__nil, x1)) -> c4(LENGTH(cons(nil, x1))) by LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(nil, z0)))
----------------------------------------

(154)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(nil, z0)))
S tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2)))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(nil, z0)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH_1, LENGTH1_1, ACTIVATE_1

Compound Symbols:   c3_2, c4_2, c4_1, c8_1, c9_1, c11_1, c3_1


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

(155) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace LENGTH(n__cons(x0, n__cons(n__nil, x2))) -> c3(LENGTH1(cons(nil, x2))) by LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(nil, z1)))
----------------------------------------

(156)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(nil, z1)))
S tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(nil, z1)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH_1, LENGTH1_1, ACTIVATE_1

Compound Symbols:   c3_2, c4_2, c4_1, c8_1, c9_1, c11_1, c3_1


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

(157) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(nil, z0))) by LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
----------------------------------------

(158)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(nil, z1)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
S tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(nil, z1)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH_1, LENGTH1_1, ACTIVATE_1

Compound Symbols:   c3_2, c4_2, c4_1, c8_1, c9_1, c11_1, c3_1


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

(159) CdtRewritingProof (BOTH BOUNDS(ID, ID))
Used rewriting to replace LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(nil, z1))) by LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
----------------------------------------

(160)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
S tuples:
   LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0))
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH_1, LENGTH1_1, ACTIVATE_1

Compound Symbols:   c3_2, c4_2, c4_1, c8_1, c9_1, c11_1, c3_1


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

(161) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace LENGTH(n__cons(x0, z0)) -> c3(LENGTH1(z0), ACTIVATE(z0)) by 
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(y0))) -> c3(LENGTH1(n__s(y0)), ACTIVATE(n__s(y0)))
   LENGTH(n__cons(z0, n__cons(y0, y1))) -> c3(LENGTH1(n__cons(y0, y1)), ACTIVATE(n__cons(y0, y1)))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__cons(n__nil, y0))) -> c3(LENGTH1(n__cons(n__nil, y0)), ACTIVATE(n__cons(n__nil, y0)))

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

(162)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__cons(n__nil, y0))) -> c3(LENGTH1(n__cons(n__nil, y0)), ACTIVATE(n__cons(n__nil, y0)))
S tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(LENGTH(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)), ACTIVATE(n__from(n__nil)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__cons(n__nil, y0))) -> c3(LENGTH1(n__cons(n__nil, y0)), ACTIVATE(n__cons(n__nil, y0)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c4_1, c3_2, c8_1, c9_1, c11_1, c3_1


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

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

(164)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
S tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c4_1, c3_2, c8_1, c9_1, c11_1, c3_1


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

(165) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
We considered the (Usable) Rules:none
And the Tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(ACTIVATE(x_1)) = 0
   POL(LENGTH(x_1)) = [1]
   POL(LENGTH1(x_1)) = [1]
   POL(activate(x_1)) = 0
   POL(c11(x_1)) = x_1
   POL(c3(x_1)) = x_1
   POL(c3(x_1, x_2)) = x_1 + x_2
   POL(c4(x_1)) = x_1
   POL(c4(x_1, x_2)) = x_1 + x_2
   POL(c8(x_1)) = x_1
   POL(c9(x_1)) = x_1
   POL(cons(x_1, x_2)) = 0
   POL(from(x_1)) = 0
   POL(n__cons(x_1, x_2)) = 0
   POL(n__from(x_1)) = 0
   POL(n__nil) = 0
   POL(n__s(x_1)) = 0
   POL(nil) = [1]
   POL(s(x_1)) = 0

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

(166)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
S tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c4_1, c3_2, c8_1, c9_1, c11_1, c3_1


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

(167) CdtRuleRemovalProof (UPPER BOUND(ADD(n^1)))
Found a reduction pair which oriented the following tuples strictly. Hence they can be removed from S.
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
We considered the (Usable) Rules:
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   cons(z0, z1) -> n__cons(z0, z1)
And the Tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
The order we found is given by the following interpretation:

Polynomial interpretation :

   POL(ACTIVATE(x_1)) = 0
   POL(LENGTH(x_1)) = x_1
   POL(LENGTH1(x_1)) = x_1
   POL(activate(x_1)) = 0
   POL(c11(x_1)) = x_1
   POL(c3(x_1)) = x_1
   POL(c3(x_1, x_2)) = x_1 + x_2
   POL(c4(x_1)) = x_1
   POL(c4(x_1, x_2)) = x_1 + x_2
   POL(c8(x_1)) = x_1
   POL(c9(x_1)) = x_1
   POL(cons(x_1, x_2)) = [1]
   POL(from(x_1)) = [1]
   POL(n__cons(x_1, x_2)) = [1]
   POL(n__from(x_1)) = [1]
   POL(n__nil) = 0
   POL(n__s(x_1)) = 0
   POL(nil) = [1]
   POL(s(x_1)) = 0

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

(168)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
S tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
K tuples:
   LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0)))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c4_1, c3_2, c8_1, c9_1, c11_1, c3_1


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

(169) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace LENGTH1(n__from(x0)) -> c4(ACTIVATE(n__from(x0))) by 
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))

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

(170)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
S tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
K tuples:
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c4_1, c3_2, c8_1, c9_1, c11_1, c3_1


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

(171) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0))) by 
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))

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

(172)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__s(x0)) -> c4(ACTIVATE(n__s(x0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
S tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
K tuples:
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c4_1, c3_2, c8_1, c9_1, c11_1, c3_1


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

(173) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace LENGTH1(n__s(z0)) -> c4(ACTIVATE(n__s(z0))) by 
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))

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

(174)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
S tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
K tuples:
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c3_2, c8_1, c4_1, c9_1, c11_1, c3_1


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

(175) CdtLeafRemovalProof (BOTH BOUNDS(ID, ID))
Removed 1 trailing nodes:
   LENGTH(n__cons(x0, n__s(n__nil))) -> c3(LENGTH1(n__s(n__nil)))

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

(176)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
S tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
K tuples:
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c3_2, c8_1, c4_1, c9_1, c11_1, c3_1


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

(177) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace ACTIVATE(n__from(n__from(y0))) -> c8(ACTIVATE(n__from(y0))) by 
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))

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

(178)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
S tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
K tuples:
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c3_2, c8_1, c4_1, c9_1, c11_1, c3_1


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

(179) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace ACTIVATE(n__from(n__s(y0))) -> c8(ACTIVATE(n__s(y0))) by 
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))

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

(180)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
S tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
K tuples:
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c3_2, c8_1, c4_1, c9_1, c11_1, c3_1


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

(181) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace ACTIVATE(n__from(n__cons(y0, y1))) -> c8(ACTIVATE(n__cons(y0, y1))) by 
   ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))) -> c8(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))

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

(182)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))) -> c8(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
S tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))) -> c8(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
K tuples:
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c3_2, c4_1, c9_1, c11_1, c3_1, c8_1


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

(183) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace ACTIVATE(n__s(n__s(y0))) -> c9(ACTIVATE(n__s(y0))) by 
   ACTIVATE(n__s(n__s(n__s(y0)))) -> c9(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__s(n__s(n__cons(y0, y1)))) -> c9(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__s(n__s(n__from(n__from(y0))))) -> c9(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__s(y0))))) -> c9(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))

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

(184)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))) -> c8(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__s(n__s(y0)))) -> c9(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__s(n__s(n__cons(y0, y1)))) -> c9(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__s(n__s(n__from(n__from(y0))))) -> c9(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__s(y0))))) -> c9(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
S tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))) -> c8(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__s(n__s(y0)))) -> c9(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__s(n__s(n__cons(y0, y1)))) -> c9(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__s(n__s(n__from(n__from(y0))))) -> c9(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__s(y0))))) -> c9(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
K tuples:
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c3_2, c4_1, c9_1, c11_1, c3_1, c8_1


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

(185) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace ACTIVATE(n__s(n__cons(y0, y1))) -> c9(ACTIVATE(n__cons(y0, y1))) by 
   ACTIVATE(n__s(n__cons(n__cons(y0, y1), z1))) -> c9(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__from(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__from(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__s(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))

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

(186)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))) -> c8(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__s(n__s(y0)))) -> c9(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__s(n__s(n__cons(y0, y1)))) -> c9(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__s(n__s(n__from(n__from(y0))))) -> c9(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__s(y0))))) -> c9(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__cons(n__cons(y0, y1), z1))) -> c9(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__from(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__from(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__s(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
S tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))) -> c8(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__s(n__s(y0)))) -> c9(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__s(n__s(n__cons(y0, y1)))) -> c9(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__s(n__s(n__from(n__from(y0))))) -> c9(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__s(y0))))) -> c9(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__cons(n__cons(y0, y1), z1))) -> c9(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__from(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__from(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__s(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
K tuples:
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c3_2, c4_1, c9_1, c11_1, c3_1, c8_1


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

(187) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace ACTIVATE(n__s(n__from(n__from(y0)))) -> c9(ACTIVATE(n__from(n__from(y0)))) by 
   ACTIVATE(n__s(n__from(n__from(n__from(y0))))) -> c9(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__s(y0))))) -> c9(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))

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

(188)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))) -> c8(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__s(n__s(y0)))) -> c9(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__s(n__s(n__cons(y0, y1)))) -> c9(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__s(n__s(n__from(n__from(y0))))) -> c9(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__s(y0))))) -> c9(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__cons(n__cons(y0, y1), z1))) -> c9(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__from(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__from(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__s(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__from(n__from(n__from(y0))))) -> c9(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__s(y0))))) -> c9(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
S tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))) -> c8(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__s(n__s(y0)))) -> c9(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__s(n__s(n__cons(y0, y1)))) -> c9(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__s(n__s(n__from(n__from(y0))))) -> c9(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__s(y0))))) -> c9(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__cons(n__cons(y0, y1), z1))) -> c9(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__from(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__from(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__s(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__from(n__from(n__from(y0))))) -> c9(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__s(y0))))) -> c9(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
K tuples:
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c3_2, c4_1, c9_1, c11_1, c3_1, c8_1


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

(189) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace ACTIVATE(n__s(n__from(n__s(y0)))) -> c9(ACTIVATE(n__from(n__s(y0)))) by 
   ACTIVATE(n__s(n__from(n__s(n__s(y0))))) -> c9(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__s(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__from(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__s(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__cons(y0, y1)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))

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

(190)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))) -> c8(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__s(n__s(y0)))) -> c9(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__s(n__s(n__cons(y0, y1)))) -> c9(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__s(n__s(n__from(n__from(y0))))) -> c9(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__s(y0))))) -> c9(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__cons(n__cons(y0, y1), z1))) -> c9(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__from(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__from(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__s(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__from(n__from(n__from(y0))))) -> c9(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__s(y0))))) -> c9(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__s(y0))))) -> c9(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__s(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__from(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__s(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__cons(y0, y1)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))
S tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))) -> c8(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__s(n__s(y0)))) -> c9(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__s(n__s(n__cons(y0, y1)))) -> c9(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__s(n__s(n__from(n__from(y0))))) -> c9(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__s(y0))))) -> c9(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__cons(n__cons(y0, y1), z1))) -> c9(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__from(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__from(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__s(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__from(n__from(n__from(y0))))) -> c9(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__s(y0))))) -> c9(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__s(y0))))) -> c9(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__s(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__from(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__s(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__cons(y0, y1)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))
K tuples:
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c3_2, c4_1, c9_1, c11_1, c3_1, c8_1


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

(191) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace ACTIVATE(n__s(n__from(n__cons(y0, y1)))) -> c9(ACTIVATE(n__from(n__cons(y0, y1)))) by 
   ACTIVATE(n__s(n__from(n__cons(n__cons(y0, y1), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__from(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__from(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__s(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))))

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

(192)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))) -> c8(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__s(n__s(y0)))) -> c9(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__s(n__s(n__cons(y0, y1)))) -> c9(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__s(n__s(n__from(n__from(y0))))) -> c9(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__s(y0))))) -> c9(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__cons(n__cons(y0, y1), z1))) -> c9(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__from(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__from(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__s(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__from(n__from(n__from(y0))))) -> c9(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__s(y0))))) -> c9(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__s(y0))))) -> c9(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__s(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__from(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__s(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__cons(y0, y1)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))
   ACTIVATE(n__s(n__from(n__cons(n__cons(y0, y1), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__from(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__from(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__s(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))))
S tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))) -> c8(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__s(n__s(y0)))) -> c9(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__s(n__s(n__cons(y0, y1)))) -> c9(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__s(n__s(n__from(n__from(y0))))) -> c9(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__s(y0))))) -> c9(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__cons(n__cons(y0, y1), z1))) -> c9(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__from(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__from(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__s(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__from(n__from(n__from(y0))))) -> c9(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__s(y0))))) -> c9(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__s(y0))))) -> c9(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__s(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__from(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__s(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__cons(y0, y1)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))
   ACTIVATE(n__s(n__from(n__cons(n__cons(y0, y1), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__from(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__from(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__s(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))))
K tuples:
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c3_2, c4_1, c11_1, c3_1, c8_1, c9_1


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

(193) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace ACTIVATE(n__cons(n__cons(y0, y1), z1)) -> c11(ACTIVATE(n__cons(y0, y1))) by 
   ACTIVATE(n__cons(n__cons(n__cons(y0, y1), z1), z2)) -> c11(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__from(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__from(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__s(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__cons(y0, y1))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))

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

(194)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))) -> c8(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__s(n__s(y0)))) -> c9(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__s(n__s(n__cons(y0, y1)))) -> c9(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__s(n__s(n__from(n__from(y0))))) -> c9(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__s(y0))))) -> c9(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__cons(n__cons(y0, y1), z1))) -> c9(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__from(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__from(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__s(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__from(n__from(n__from(y0))))) -> c9(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__s(y0))))) -> c9(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__s(y0))))) -> c9(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__s(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__from(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__s(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__cons(y0, y1)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))
   ACTIVATE(n__s(n__from(n__cons(n__cons(y0, y1), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__from(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__from(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__s(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))))
   ACTIVATE(n__cons(n__cons(n__cons(y0, y1), z1), z2)) -> c11(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__from(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__from(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__s(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__cons(y0, y1))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
S tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))) -> c8(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__s(n__s(y0)))) -> c9(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__s(n__s(n__cons(y0, y1)))) -> c9(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__s(n__s(n__from(n__from(y0))))) -> c9(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__s(y0))))) -> c9(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__cons(n__cons(y0, y1), z1))) -> c9(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__from(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__from(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__s(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__from(n__from(n__from(y0))))) -> c9(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__s(y0))))) -> c9(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__s(y0))))) -> c9(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__s(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__from(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__s(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__cons(y0, y1)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))
   ACTIVATE(n__s(n__from(n__cons(n__cons(y0, y1), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__from(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__from(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__s(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))))
   ACTIVATE(n__cons(n__cons(n__cons(y0, y1), z1), z2)) -> c11(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__from(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__from(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__s(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__cons(y0, y1))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
K tuples:
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c3_2, c4_1, c11_1, c3_1, c8_1, c9_1


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

(195) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace ACTIVATE(n__cons(n__from(n__from(y0)), z1)) -> c11(ACTIVATE(n__from(n__from(y0)))) by 
   ACTIVATE(n__cons(n__from(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__from(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__from(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))

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

(196)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))) -> c8(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__s(n__s(y0)))) -> c9(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__s(n__s(n__cons(y0, y1)))) -> c9(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__s(n__s(n__from(n__from(y0))))) -> c9(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__s(y0))))) -> c9(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__cons(n__cons(y0, y1), z1))) -> c9(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__from(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__from(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__s(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__from(n__from(n__from(y0))))) -> c9(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__s(y0))))) -> c9(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__s(y0))))) -> c9(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__s(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__from(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__s(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__cons(y0, y1)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))
   ACTIVATE(n__s(n__from(n__cons(n__cons(y0, y1), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__from(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__from(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__s(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))))
   ACTIVATE(n__cons(n__cons(n__cons(y0, y1), z1), z2)) -> c11(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__from(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__from(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__s(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__cons(y0, y1))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__cons(n__from(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__from(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__from(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
S tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))) -> c8(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__s(n__s(y0)))) -> c9(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__s(n__s(n__cons(y0, y1)))) -> c9(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__s(n__s(n__from(n__from(y0))))) -> c9(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__s(y0))))) -> c9(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__cons(n__cons(y0, y1), z1))) -> c9(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__from(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__from(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__s(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__from(n__from(n__from(y0))))) -> c9(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__s(y0))))) -> c9(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__s(y0))))) -> c9(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__s(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__from(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__s(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__cons(y0, y1)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))
   ACTIVATE(n__s(n__from(n__cons(n__cons(y0, y1), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__from(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__from(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__s(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))))
   ACTIVATE(n__cons(n__cons(n__cons(y0, y1), z1), z2)) -> c11(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__from(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__from(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__s(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__cons(y0, y1))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__cons(n__from(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__from(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__from(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
K tuples:
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c3_2, c4_1, c11_1, c3_1, c8_1, c9_1


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

(197) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace ACTIVATE(n__cons(n__from(n__s(y0)), z1)) -> c11(ACTIVATE(n__from(n__s(y0)))) by 
   ACTIVATE(n__cons(n__from(n__s(n__s(y0))), z1)) -> c11(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__cons(n__from(n__s(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__from(y0)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__s(y0)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__cons(y0, y1)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))

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

(198)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))) -> c8(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__s(n__s(y0)))) -> c9(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__s(n__s(n__cons(y0, y1)))) -> c9(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__s(n__s(n__from(n__from(y0))))) -> c9(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__s(y0))))) -> c9(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__cons(n__cons(y0, y1), z1))) -> c9(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__from(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__from(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__s(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__from(n__from(n__from(y0))))) -> c9(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__s(y0))))) -> c9(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__s(y0))))) -> c9(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__s(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__from(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__s(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__cons(y0, y1)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))
   ACTIVATE(n__s(n__from(n__cons(n__cons(y0, y1), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__from(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__from(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__s(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))))
   ACTIVATE(n__cons(n__cons(n__cons(y0, y1), z1), z2)) -> c11(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__from(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__from(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__s(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__cons(y0, y1))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__cons(n__from(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__from(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__from(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__cons(n__from(n__s(n__s(y0))), z1)) -> c11(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__cons(n__from(n__s(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__from(y0)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__s(y0)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__cons(y0, y1)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))
S tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))) -> c8(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__s(n__s(y0)))) -> c9(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__s(n__s(n__cons(y0, y1)))) -> c9(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__s(n__s(n__from(n__from(y0))))) -> c9(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__s(y0))))) -> c9(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__cons(n__cons(y0, y1), z1))) -> c9(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__from(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__from(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__s(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__from(n__from(n__from(y0))))) -> c9(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__s(y0))))) -> c9(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__s(y0))))) -> c9(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__s(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__from(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__s(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__cons(y0, y1)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))
   ACTIVATE(n__s(n__from(n__cons(n__cons(y0, y1), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__from(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__from(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__s(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))))
   ACTIVATE(n__cons(n__cons(n__cons(y0, y1), z1), z2)) -> c11(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__from(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__from(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__s(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__cons(y0, y1))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__cons(n__from(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__from(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__from(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__cons(n__from(n__s(n__s(y0))), z1)) -> c11(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__cons(n__from(n__s(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__from(y0)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__s(y0)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__cons(y0, y1)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))
K tuples:
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c3_2, c4_1, c11_1, c3_1, c8_1, c9_1


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

(199) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__from(n__cons(y0, y1)))) by 
   ACTIVATE(n__cons(n__from(n__cons(n__cons(y0, y1), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__from(n__from(y0)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__from(n__s(y0)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__from(n__cons(y0, y1)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__s(y0)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__cons(y0, y1)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__from(n__from(y0))), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__from(n__s(y0))), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))))

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

(200)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))) -> c8(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__s(n__s(y0)))) -> c9(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__s(n__s(n__cons(y0, y1)))) -> c9(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__s(n__s(n__from(n__from(y0))))) -> c9(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__s(y0))))) -> c9(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__cons(n__cons(y0, y1), z1))) -> c9(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__from(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__from(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__s(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__from(n__from(n__from(y0))))) -> c9(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__s(y0))))) -> c9(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__s(y0))))) -> c9(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__s(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__from(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__s(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__cons(y0, y1)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))
   ACTIVATE(n__s(n__from(n__cons(n__cons(y0, y1), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__from(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__from(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__s(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))))
   ACTIVATE(n__cons(n__cons(n__cons(y0, y1), z1), z2)) -> c11(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__from(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__from(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__s(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__cons(y0, y1))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__cons(n__from(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__from(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__from(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__cons(n__from(n__s(n__s(y0))), z1)) -> c11(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__cons(n__from(n__s(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__from(y0)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__s(y0)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__cons(y0, y1)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))
   ACTIVATE(n__cons(n__from(n__cons(n__cons(y0, y1), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__from(n__from(y0)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__from(n__s(y0)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__from(n__cons(y0, y1)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__s(y0)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__cons(y0, y1)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__from(n__from(y0))), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__from(n__s(y0))), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))))
S tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))) -> c8(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__s(n__s(y0)))) -> c9(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__s(n__s(n__cons(y0, y1)))) -> c9(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__s(n__s(n__from(n__from(y0))))) -> c9(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__s(y0))))) -> c9(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__cons(n__cons(y0, y1), z1))) -> c9(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__from(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__from(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__s(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__from(n__from(n__from(y0))))) -> c9(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__s(y0))))) -> c9(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__s(y0))))) -> c9(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__s(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__from(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__s(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__cons(y0, y1)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))
   ACTIVATE(n__s(n__from(n__cons(n__cons(y0, y1), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__from(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__from(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__s(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))))
   ACTIVATE(n__cons(n__cons(n__cons(y0, y1), z1), z2)) -> c11(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__from(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__from(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__s(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__cons(y0, y1))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__cons(n__from(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__from(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__from(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__cons(n__from(n__s(n__s(y0))), z1)) -> c11(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__cons(n__from(n__s(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__from(y0)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__s(y0)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__cons(y0, y1)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))
   ACTIVATE(n__cons(n__from(n__cons(n__cons(y0, y1), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__from(n__from(y0)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__from(n__s(y0)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__from(n__cons(y0, y1)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__s(y0)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__cons(y0, y1)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__from(n__from(y0))), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__from(n__s(y0))), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))))
K tuples:
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c3_2, c4_1, c11_1, c3_1, c8_1, c9_1


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

(201) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace ACTIVATE(n__cons(n__s(n__s(y0)), z1)) -> c11(ACTIVATE(n__s(n__s(y0)))) by 
   ACTIVATE(n__cons(n__s(n__s(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__s(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__s(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__cons(n__s(n__s(n__from(n__from(y0)))), z1)) -> c11(ACTIVATE(n__s(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__cons(n__s(n__s(n__from(n__s(y0)))), z1)) -> c11(ACTIVATE(n__s(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__cons(n__s(n__s(n__from(n__cons(y0, y1)))), z1)) -> c11(ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))))

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

(202)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))) -> c8(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__s(n__s(y0)))) -> c9(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__s(n__s(n__cons(y0, y1)))) -> c9(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__s(n__s(n__from(n__from(y0))))) -> c9(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__s(y0))))) -> c9(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__cons(n__cons(y0, y1), z1))) -> c9(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__from(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__from(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__s(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__from(n__from(n__from(y0))))) -> c9(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__s(y0))))) -> c9(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__s(y0))))) -> c9(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__s(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__from(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__s(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__cons(y0, y1)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))
   ACTIVATE(n__s(n__from(n__cons(n__cons(y0, y1), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__from(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__from(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__s(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))))
   ACTIVATE(n__cons(n__cons(n__cons(y0, y1), z1), z2)) -> c11(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__from(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__from(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__s(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__cons(y0, y1))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__cons(n__from(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__from(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__from(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__cons(n__from(n__s(n__s(y0))), z1)) -> c11(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__cons(n__from(n__s(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__from(y0)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__s(y0)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__cons(y0, y1)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))
   ACTIVATE(n__cons(n__from(n__cons(n__cons(y0, y1), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__from(n__from(y0)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__from(n__s(y0)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__from(n__cons(y0, y1)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__s(y0)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__cons(y0, y1)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__from(n__from(y0))), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__from(n__s(y0))), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))))
   ACTIVATE(n__cons(n__s(n__s(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__s(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__s(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__cons(n__s(n__s(n__from(n__from(y0)))), z1)) -> c11(ACTIVATE(n__s(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__cons(n__s(n__s(n__from(n__s(y0)))), z1)) -> c11(ACTIVATE(n__s(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__cons(n__s(n__s(n__from(n__cons(y0, y1)))), z1)) -> c11(ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))))
S tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))) -> c8(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__s(n__s(y0)))) -> c9(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__s(n__s(n__cons(y0, y1)))) -> c9(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__s(n__s(n__from(n__from(y0))))) -> c9(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__s(y0))))) -> c9(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__cons(n__cons(y0, y1), z1))) -> c9(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__from(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__from(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__s(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__from(n__from(n__from(y0))))) -> c9(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__s(y0))))) -> c9(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__s(y0))))) -> c9(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__s(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__from(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__s(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__cons(y0, y1)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))
   ACTIVATE(n__s(n__from(n__cons(n__cons(y0, y1), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__from(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__from(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__s(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))))
   ACTIVATE(n__cons(n__cons(n__cons(y0, y1), z1), z2)) -> c11(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__from(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__from(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__s(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__cons(y0, y1))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__cons(n__from(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__from(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__from(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__cons(n__from(n__s(n__s(y0))), z1)) -> c11(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__cons(n__from(n__s(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__from(y0)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__s(y0)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__cons(y0, y1)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))
   ACTIVATE(n__cons(n__from(n__cons(n__cons(y0, y1), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__from(n__from(y0)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__from(n__s(y0)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__from(n__cons(y0, y1)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__s(y0)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__cons(y0, y1)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__from(n__from(y0))), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__from(n__s(y0))), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))))
   ACTIVATE(n__cons(n__s(n__s(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__s(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__s(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__cons(n__s(n__s(n__from(n__from(y0)))), z1)) -> c11(ACTIVATE(n__s(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__cons(n__s(n__s(n__from(n__s(y0)))), z1)) -> c11(ACTIVATE(n__s(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__cons(n__s(n__s(n__from(n__cons(y0, y1)))), z1)) -> c11(ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))))
K tuples:
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c3_2, c4_1, c11_1, c3_1, c8_1, c9_1


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

(203) CdtForwardInstantiationProof (BOTH BOUNDS(ID, ID))
Use forward instantiation to replace ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)) -> c11(ACTIVATE(n__s(n__cons(y0, y1)))) by 
   ACTIVATE(n__cons(n__s(n__cons(n__cons(y0, y1), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__cons(y0, y1), z1))))
   ACTIVATE(n__cons(n__s(n__cons(n__from(n__from(y0)), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__from(n__from(y0)), z1))))
   ACTIVATE(n__cons(n__s(n__cons(n__from(n__s(y0)), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__from(n__s(y0)), z1))))
   ACTIVATE(n__cons(n__s(n__cons(n__from(n__cons(y0, y1)), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__from(n__cons(y0, y1)), z1))))
   ACTIVATE(n__cons(n__s(n__cons(n__s(n__s(y0)), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__s(n__s(y0)), z1))))
   ACTIVATE(n__cons(n__s(n__cons(n__s(n__cons(y0, y1)), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__s(n__cons(y0, y1)), z1))))
   ACTIVATE(n__cons(n__s(n__cons(n__s(n__from(n__from(y0))), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__s(n__from(n__from(y0))), z1))))
   ACTIVATE(n__cons(n__s(n__cons(n__s(n__from(n__s(y0))), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__s(n__from(n__s(y0))), z1))))
   ACTIVATE(n__cons(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1))))

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

(204)
Obligation:
Complexity Dependency Tuples Problem

Rules:
   activate(n__from(z0)) -> from(activate(z0))
   activate(n__s(z0)) -> s(activate(z0))
   activate(n__nil) -> nil
   activate(n__cons(z0, z1)) -> cons(activate(z0), z1)
   activate(z0) -> z0
   from(z0) -> cons(z0, n__from(n__s(z0)))
   from(z0) -> n__from(z0)
   s(z0) -> n__s(z0)
   nil -> n__nil
   cons(z0, z1) -> n__cons(z0, z1)
Tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))) -> c8(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__s(n__s(y0)))) -> c9(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__s(n__s(n__cons(y0, y1)))) -> c9(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__s(n__s(n__from(n__from(y0))))) -> c9(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__s(y0))))) -> c9(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__cons(n__cons(y0, y1), z1))) -> c9(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__from(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__from(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__s(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__from(n__from(n__from(y0))))) -> c9(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__s(y0))))) -> c9(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__s(y0))))) -> c9(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__s(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__from(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__s(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__cons(y0, y1)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))
   ACTIVATE(n__s(n__from(n__cons(n__cons(y0, y1), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__from(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__from(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__s(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))))
   ACTIVATE(n__cons(n__cons(n__cons(y0, y1), z1), z2)) -> c11(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__from(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__from(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__s(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__cons(y0, y1))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__cons(n__from(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__from(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__from(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__cons(n__from(n__s(n__s(y0))), z1)) -> c11(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__cons(n__from(n__s(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__from(y0)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__s(y0)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__cons(y0, y1)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))
   ACTIVATE(n__cons(n__from(n__cons(n__cons(y0, y1), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__from(n__from(y0)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__from(n__s(y0)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__from(n__cons(y0, y1)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__s(y0)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__cons(y0, y1)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__from(n__from(y0))), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__from(n__s(y0))), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))))
   ACTIVATE(n__cons(n__s(n__s(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__s(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__s(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__cons(n__s(n__s(n__from(n__from(y0)))), z1)) -> c11(ACTIVATE(n__s(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__cons(n__s(n__s(n__from(n__s(y0)))), z1)) -> c11(ACTIVATE(n__s(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__cons(n__s(n__s(n__from(n__cons(y0, y1)))), z1)) -> c11(ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))))
   ACTIVATE(n__cons(n__s(n__cons(n__cons(y0, y1), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__cons(y0, y1), z1))))
   ACTIVATE(n__cons(n__s(n__cons(n__from(n__from(y0)), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__from(n__from(y0)), z1))))
   ACTIVATE(n__cons(n__s(n__cons(n__from(n__s(y0)), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__from(n__s(y0)), z1))))
   ACTIVATE(n__cons(n__s(n__cons(n__from(n__cons(y0, y1)), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__from(n__cons(y0, y1)), z1))))
   ACTIVATE(n__cons(n__s(n__cons(n__s(n__s(y0)), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__s(n__s(y0)), z1))))
   ACTIVATE(n__cons(n__s(n__cons(n__s(n__cons(y0, y1)), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__s(n__cons(y0, y1)), z1))))
   ACTIVATE(n__cons(n__s(n__cons(n__s(n__from(n__from(y0))), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__s(n__from(n__from(y0))), z1))))
   ACTIVATE(n__cons(n__s(n__cons(n__s(n__from(n__s(y0))), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__s(n__from(n__s(y0))), z1))))
   ACTIVATE(n__cons(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1))))
S tuples:
   LENGTH1(n__from(x0)) -> c4(LENGTH(cons(activate(x0), n__from(n__s(activate(x0))))), ACTIVATE(n__from(x0)))
   LENGTH1(n__from(n__from(z0))) -> c4(LENGTH(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH1(n__from(n__s(z0))) -> c4(LENGTH(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH1(n__from(n__cons(z0, z1))) -> c4(LENGTH(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH1(n__from(z0)) -> c4(LENGTH(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH1(n__cons(x0, z1)) -> c4(LENGTH(n__cons(activate(x0), z1)), ACTIVATE(n__cons(x0, z1)))
   LENGTH1(n__cons(n__from(z0), x1)) -> c4(LENGTH(cons(from(activate(z0)), x1)), ACTIVATE(n__cons(n__from(z0), x1)))
   LENGTH1(n__cons(n__s(z0), x1)) -> c4(LENGTH(cons(s(activate(z0)), x1)), ACTIVATE(n__cons(n__s(z0), x1)))
   LENGTH1(n__cons(n__cons(z0, z1), x1)) -> c4(LENGTH(cons(cons(activate(z0), z1), x1)), ACTIVATE(n__cons(n__cons(z0, z1), x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(cons(activate(x1), n__from(n__s(activate(x1))))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(x1))) -> c3(LENGTH1(n__from(activate(x1))), ACTIVATE(n__from(x1)))
   LENGTH(n__cons(x0, n__from(n__from(z0)))) -> c3(LENGTH1(from(from(activate(z0)))), ACTIVATE(n__from(n__from(z0))))
   LENGTH(n__cons(x0, n__from(n__s(z0)))) -> c3(LENGTH1(from(s(activate(z0)))), ACTIVATE(n__from(n__s(z0))))
   LENGTH(n__cons(x0, n__from(n__cons(z0, z1)))) -> c3(LENGTH1(from(cons(activate(z0), z1))), ACTIVATE(n__from(n__cons(z0, z1))))
   LENGTH(n__cons(x0, n__from(z0))) -> c3(LENGTH1(from(z0)), ACTIVATE(n__from(z0)))
   LENGTH(n__cons(x0, n__cons(x1, z1))) -> c3(LENGTH1(n__cons(activate(x1), z1)), ACTIVATE(n__cons(x1, z1)))
   LENGTH(n__cons(x0, n__cons(n__from(z0), x2))) -> c3(LENGTH1(cons(from(activate(z0)), x2)), ACTIVATE(n__cons(n__from(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__s(z0), x2))) -> c3(LENGTH1(cons(s(activate(z0)), x2)), ACTIVATE(n__cons(n__s(z0), x2)))
   LENGTH(n__cons(x0, n__cons(n__cons(z0, z1), x2))) -> c3(LENGTH1(cons(cons(activate(z0), z1), x2)), ACTIVATE(n__cons(n__cons(z0, z1), x2)))
   LENGTH1(n__from(n__nil)) -> c4(LENGTH(from(n__nil)))
   ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__cons(z0, z1)) -> c4(LENGTH(n__cons(z0, z1)), ACTIVATE(n__cons(z0, z1)))
   LENGTH1(n__cons(y0, n__from(y1))) -> c4(LENGTH(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH1(n__cons(y0, n__from(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH1(n__cons(y0, n__from(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__s(y1))) -> c4(LENGTH(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH1(n__cons(y0, n__s(n__from(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH1(n__cons(y0, n__s(n__s(y1)))) -> c4(LENGTH(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))) -> c4(LENGTH(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH1(n__cons(y0, n__cons(y1, y2))) -> c4(LENGTH(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))) -> c4(LENGTH(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))) -> c4(LENGTH(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH1(n__cons(y0, n__from(n__nil))) -> c4(LENGTH(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH1(n__cons(y0, n__s(n__nil))) -> c4(LENGTH(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH1(n__cons(n__cons(y0, y1), y2)) -> c4(LENGTH(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH1(n__cons(n__from(n__from(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH1(n__cons(n__from(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__s(y0)), y1)) -> c4(LENGTH(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)) -> c4(LENGTH(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)) -> c4(LENGTH(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)) -> c4(LENGTH(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH1(n__cons(y0, n__cons(n__nil, y1))) -> c4(LENGTH(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__cons(z1, z2))) -> c3(LENGTH1(n__cons(z1, z2)), ACTIVATE(n__cons(z1, z2)))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(from(n__nil)))
   LENGTH1(n__cons(n__nil, z0)) -> c4(LENGTH(n__cons(n__nil, z0)))
   LENGTH(n__cons(z0, n__cons(n__nil, z1))) -> c3(LENGTH1(n__cons(n__nil, z1)))
   LENGTH(n__cons(z0, n__from(y0))) -> c3(LENGTH1(n__from(y0)), ACTIVATE(n__from(y0)))
   LENGTH(n__cons(z0, n__from(n__from(y0)))) -> c3(LENGTH1(n__from(n__from(y0))), ACTIVATE(n__from(n__from(y0))))
   LENGTH(n__cons(z0, n__from(n__s(y0)))) -> c3(LENGTH1(n__from(n__s(y0))), ACTIVATE(n__from(n__s(y0))))
   LENGTH(n__cons(z0, n__from(n__cons(y0, y1)))) -> c3(LENGTH1(n__from(n__cons(y0, y1))), ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__cons(n__from(y0), y1))) -> c3(LENGTH1(n__cons(n__from(y0), y1)), ACTIVATE(n__cons(n__from(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(y0), y1))) -> c3(LENGTH1(n__cons(n__s(y0), y1)), ACTIVATE(n__cons(n__s(y0), y1)))
   LENGTH(n__cons(z0, n__cons(n__cons(y0, y1), y2))) -> c3(LENGTH1(n__cons(n__cons(y0, y1), y2)), ACTIVATE(n__cons(n__cons(y0, y1), y2)))
   LENGTH(n__cons(z0, n__cons(n__from(n__from(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__from(y0)), y1)), ACTIVATE(n__cons(n__from(n__from(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__from(n__s(y0)), y1)), ACTIVATE(n__cons(n__from(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__from(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__from(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__from(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__s(y0)), y1))) -> c3(LENGTH1(n__cons(n__s(n__s(y0)), y1)), ACTIVATE(n__cons(n__s(n__s(y0)), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__cons(y0, y1)), y2))) -> c3(LENGTH1(n__cons(n__s(n__cons(y0, y1)), y2)), ACTIVATE(n__cons(n__s(n__cons(y0, y1)), y2)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__from(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__from(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__from(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__s(y0))), y1))) -> c3(LENGTH1(n__cons(n__s(n__from(n__s(y0))), y1)), ACTIVATE(n__cons(n__s(n__from(n__s(y0))), y1)))
   LENGTH(n__cons(z0, n__cons(n__s(n__from(n__cons(y0, y1))), y2))) -> c3(LENGTH1(n__cons(n__s(n__from(n__cons(y0, y1))), y2)), ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), y2)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(y1)))) -> c3(LENGTH1(n__cons(y0, n__from(y1))), ACTIVATE(n__cons(y0, n__from(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__from(y1)))), ACTIVATE(n__cons(y0, n__from(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__from(n__s(y1)))), ACTIVATE(n__cons(y0, n__from(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__from(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__from(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(y1)))) -> c3(LENGTH1(n__cons(y0, n__s(y1))), ACTIVATE(n__cons(y0, n__s(y1))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__from(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__from(y1)))), ACTIVATE(n__cons(y0, n__s(n__from(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__s(y1))))) -> c3(LENGTH1(n__cons(y0, n__s(n__s(y1)))), ACTIVATE(n__cons(y0, n__s(n__s(y1)))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__cons(y1, y2))))) -> c3(LENGTH1(n__cons(y0, n__s(n__cons(y1, y2)))), ACTIVATE(n__cons(y0, n__s(n__cons(y1, y2)))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(y1, y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(y1, y2))), ACTIVATE(n__cons(y0, n__cons(y1, y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__from(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__from(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__from(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__s(y1), y2)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__s(y1), y2))), ACTIVATE(n__cons(y0, n__cons(n__s(y1), y2))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__cons(y1, y2), y3)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__cons(y1, y2), y3))), ACTIVATE(n__cons(y0, n__cons(n__cons(y1, y2), y3))))
   LENGTH(n__cons(z0, n__cons(y0, n__nil))) -> c3(LENGTH1(n__cons(y0, n__nil)), ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(z0, n__cons(y0, n__from(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__from(n__nil))), ACTIVATE(n__cons(y0, n__from(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__s(n__nil)))) -> c3(LENGTH1(n__cons(y0, n__s(n__nil))), ACTIVATE(n__cons(y0, n__s(n__nil))))
   LENGTH(n__cons(z0, n__cons(y0, n__cons(n__nil, y1)))) -> c3(LENGTH1(n__cons(y0, n__cons(n__nil, y1))), ACTIVATE(n__cons(y0, n__cons(n__nil, y1))))
   LENGTH(n__cons(z0, n__from(n__nil))) -> c3(LENGTH1(n__from(n__nil)))
   ACTIVATE(n__from(n__from(n__from(y0)))) -> c8(ACTIVATE(n__from(n__from(y0))))
   ACTIVATE(n__from(n__from(n__s(y0)))) -> c8(ACTIVATE(n__from(n__s(y0))))
   ACTIVATE(n__from(n__from(n__cons(y0, y1)))) -> c8(ACTIVATE(n__from(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__s(y0)))) -> c8(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__from(n__s(n__cons(y0, y1)))) -> c8(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__from(n__s(n__from(n__from(y0))))) -> c8(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__s(y0))))) -> c8(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))) -> c8(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))) -> c8(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))) -> c8(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c8(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__s(n__s(y0)))) -> c9(ACTIVATE(n__s(n__s(y0))))
   ACTIVATE(n__s(n__s(n__cons(y0, y1)))) -> c9(ACTIVATE(n__s(n__cons(y0, y1))))
   ACTIVATE(n__s(n__s(n__from(n__from(y0))))) -> c9(ACTIVATE(n__s(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__s(y0))))) -> c9(ACTIVATE(n__s(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__cons(n__cons(y0, y1), z1))) -> c9(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__from(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__from(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__s(y0)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__cons(y0, y1)), z1))) -> c9(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__from(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__s(y0))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1))) -> c9(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__s(n__from(n__from(n__from(y0))))) -> c9(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__s(y0))))) -> c9(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__from(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__s(y0))))) -> c9(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__s(n__from(n__s(n__cons(y0, y1))))) -> c9(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__from(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__s(y0)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__s(n__from(n__s(n__from(n__cons(y0, y1)))))) -> c9(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))
   ACTIVATE(n__s(n__from(n__cons(n__cons(y0, y1), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__from(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__from(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__s(y0)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__cons(y0, y1)), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__from(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__s(y0))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))))
   ACTIVATE(n__s(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))) -> c9(ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))))
   ACTIVATE(n__cons(n__cons(n__cons(y0, y1), z1), z2)) -> c11(ACTIVATE(n__cons(n__cons(y0, y1), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__from(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__from(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__from(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__from(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__s(y0)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__s(y0)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__cons(y0, y1)), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__cons(y0, y1)), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__from(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__from(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__s(y0))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__s(y0))), z1)))
   ACTIVATE(n__cons(n__cons(n__s(n__from(n__cons(y0, y1))), z1), z2)) -> c11(ACTIVATE(n__cons(n__s(n__from(n__cons(y0, y1))), z1)))
   ACTIVATE(n__cons(n__from(n__from(n__from(y0))), z1)) -> c11(ACTIVATE(n__from(n__from(n__from(y0)))))
   ACTIVATE(n__cons(n__from(n__from(n__s(y0))), z1)) -> c11(ACTIVATE(n__from(n__from(n__s(y0)))))
   ACTIVATE(n__cons(n__from(n__from(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__from(n__from(n__cons(y0, y1)))))
   ACTIVATE(n__cons(n__from(n__s(n__s(y0))), z1)) -> c11(ACTIVATE(n__from(n__s(n__s(y0)))))
   ACTIVATE(n__cons(n__from(n__s(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__from(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__from(y0)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__s(y0)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__cons(n__from(n__s(n__from(n__cons(y0, y1)))), z1)) -> c11(ACTIVATE(n__from(n__s(n__from(n__cons(y0, y1))))))
   ACTIVATE(n__cons(n__from(n__cons(n__cons(y0, y1), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__cons(y0, y1), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__from(n__from(y0)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__from(n__from(y0)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__from(n__s(y0)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__from(n__s(y0)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__from(n__cons(y0, y1)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__from(n__cons(y0, y1)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__s(y0)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__s(y0)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__cons(y0, y1)), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__cons(y0, y1)), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__from(n__from(y0))), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__from(n__from(y0))), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__from(n__s(y0))), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__from(n__s(y0))), z1))))
   ACTIVATE(n__cons(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1)), z2)) -> c11(ACTIVATE(n__from(n__cons(n__s(n__from(n__cons(y0, y1))), z1))))
   ACTIVATE(n__cons(n__s(n__s(n__s(y0))), z1)) -> c11(ACTIVATE(n__s(n__s(n__s(y0)))))
   ACTIVATE(n__cons(n__s(n__s(n__cons(y0, y1))), z1)) -> c11(ACTIVATE(n__s(n__s(n__cons(y0, y1)))))
   ACTIVATE(n__cons(n__s(n__s(n__from(n__from(y0)))), z1)) -> c11(ACTIVATE(n__s(n__s(n__from(n__from(y0))))))
   ACTIVATE(n__cons(n__s(n__s(n__from(n__s(y0)))), z1)) -> c11(ACTIVATE(n__s(n__s(n__from(n__s(y0))))))
   ACTIVATE(n__cons(n__s(n__s(n__from(n__cons(y0, y1)))), z1)) -> c11(ACTIVATE(n__s(n__s(n__from(n__cons(y0, y1))))))
   ACTIVATE(n__cons(n__s(n__cons(n__cons(y0, y1), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__cons(y0, y1), z1))))
   ACTIVATE(n__cons(n__s(n__cons(n__from(n__from(y0)), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__from(n__from(y0)), z1))))
   ACTIVATE(n__cons(n__s(n__cons(n__from(n__s(y0)), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__from(n__s(y0)), z1))))
   ACTIVATE(n__cons(n__s(n__cons(n__from(n__cons(y0, y1)), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__from(n__cons(y0, y1)), z1))))
   ACTIVATE(n__cons(n__s(n__cons(n__s(n__s(y0)), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__s(n__s(y0)), z1))))
   ACTIVATE(n__cons(n__s(n__cons(n__s(n__cons(y0, y1)), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__s(n__cons(y0, y1)), z1))))
   ACTIVATE(n__cons(n__s(n__cons(n__s(n__from(n__from(y0))), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__s(n__from(n__from(y0))), z1))))
   ACTIVATE(n__cons(n__s(n__cons(n__s(n__from(n__s(y0))), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__s(n__from(n__s(y0))), z1))))
   ACTIVATE(n__cons(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1)), z2)) -> c11(ACTIVATE(n__s(n__cons(n__s(n__from(n__cons(y0, y1))), z1))))
K tuples:
   LENGTH1(n__from(n__from(y0))) -> c4(ACTIVATE(n__from(n__from(y0))))
   LENGTH1(n__from(n__s(y0))) -> c4(ACTIVATE(n__from(n__s(y0))))
   LENGTH1(n__from(n__cons(y0, y1))) -> c4(ACTIVATE(n__from(n__cons(y0, y1))))
   LENGTH1(n__s(n__s(y0))) -> c4(ACTIVATE(n__s(n__s(y0))))
   LENGTH1(n__s(n__cons(y0, y1))) -> c4(ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH1(n__s(n__from(n__from(y0)))) -> c4(ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH1(n__s(n__from(n__s(y0)))) -> c4(ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH1(n__s(n__from(n__cons(y0, y1)))) -> c4(ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
   LENGTH1(n__s(n__from(z0))) -> c4(LENGTH(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH1(n__s(n__s(z0))) -> c4(LENGTH(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH1(n__s(n__cons(z0, z1))) -> c4(LENGTH(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH1(n__cons(y0, n__nil)) -> c4(ACTIVATE(n__cons(y0, n__nil)))
   LENGTH(n__cons(x0, n__s(x1))) -> c3(LENGTH1(n__s(activate(x1))), ACTIVATE(n__s(x1)))
   LENGTH(n__cons(x0, n__s(n__from(z0)))) -> c3(LENGTH1(s(from(activate(z0)))), ACTIVATE(n__s(n__from(z0))))
   LENGTH(n__cons(x0, n__s(n__s(z0)))) -> c3(LENGTH1(s(s(activate(z0)))), ACTIVATE(n__s(n__s(z0))))
   LENGTH(n__cons(x0, n__s(n__cons(z0, z1)))) -> c3(LENGTH1(s(cons(activate(z0), z1))), ACTIVATE(n__s(n__cons(z0, z1))))
   LENGTH(n__cons(z0, n__s(z1))) -> c3(LENGTH1(n__s(z1)), ACTIVATE(n__s(z1)))
   LENGTH(n__cons(z0, n__s(n__from(y0)))) -> c3(LENGTH1(n__s(n__from(y0))), ACTIVATE(n__s(n__from(y0))))
   LENGTH(n__cons(z0, n__s(n__s(y0)))) -> c3(LENGTH1(n__s(n__s(y0))), ACTIVATE(n__s(n__s(y0))))
   LENGTH(n__cons(z0, n__s(n__cons(y0, y1)))) -> c3(LENGTH1(n__s(n__cons(y0, y1))), ACTIVATE(n__s(n__cons(y0, y1))))
   LENGTH(n__cons(z0, n__s(n__from(n__from(y0))))) -> c3(LENGTH1(n__s(n__from(n__from(y0)))), ACTIVATE(n__s(n__from(n__from(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__s(y0))))) -> c3(LENGTH1(n__s(n__from(n__s(y0)))), ACTIVATE(n__s(n__from(n__s(y0)))))
   LENGTH(n__cons(z0, n__s(n__from(n__cons(y0, y1))))) -> c3(LENGTH1(n__s(n__from(n__cons(y0, y1)))), ACTIVATE(n__s(n__from(n__cons(y0, y1)))))
Defined Rule Symbols:   activate_1, from_1, s_1, nil, cons_2

Defined Pair Symbols:   LENGTH1_1, LENGTH_1, ACTIVATE_1

Compound Symbols:   c4_2, c3_2, c4_1, c11_1, c3_1, c8_1, c9_1